@haneullabs/codegen 0.1.0

package/src/file-builder.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type ts from 'typescript';
+import { parseTS, printNodes } from './utils.js';
+import { relative, resolve } from 'path';
+import { getSafeName } from './render-types.js';
+
+export class FileBuilder {
+	statements: ts.Statement[] = [];
+	exports: string[] = [];
+	imports: Map<string, Set<string>> = new Map();
+	starImports: Map<string, string> = new Map();
+	protected reservedNames: Set<string> = new Set();
+
+	addImport(module: string, name: string) {
+		if (!this.imports.has(module)) {
+			this.imports.set(module, new Set());
+		}
+
+		this.imports.get(module)!.add(name);
+	}
+
+	addStarImport(module: string, name: string) {
+		const importName = this.getUnusedName(name);
+		this.starImports.set(importName, module);
+		return importName;
+	}
+
+	getUnusedName(name: string) {
+		let deConflictedName = getSafeName(name);
+
+		let i = 1;
+		while (this.reservedNames.has(deConflictedName)) {
+			deConflictedName = `${name}_${i}`;
+			i++;
+		}
+
+		return deConflictedName;
+	}
+
+	async getHeader() {
+		return [
+			'/**************************************************************',
+			' * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *',
+			' **************************************************************/',
+			'',
+		].join('\n');
+	}
+
+	async toString(modDir: string, filePath: string) {
+		const importStatements = [...this.imports.entries()].flatMap(
+			([module, names]) =>
+				parseTS`import { ${[...names].join(', ')} } from '${modulePath(module)}'`,
+		);
+		const starImportStatements = [...this.starImports.entries()].flatMap(
+			([name, module]) => parseTS`import * as ${name} from '${modulePath(module)}'`,
+		);
+
+		return `${await this.getHeader()}${printNodes(...importStatements, ...starImportStatements, ...this.statements)}`;
+
+		function modulePath(mod: string) {
+			if (!mod.startsWith('~root/')) {
+				return mod;
+			}
+
+			const sourcePath = resolve(modDir, filePath);
+			const destPath = resolve(modDir, mod.replace('~root/', './'));
+			const sourceDirectory = sourcePath.split('/').slice(0, -1).join('/');
+			const relativePath = relative(sourceDirectory, destPath);
+			return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+		}
+	}
+}

package/src/generate-utils.ts

@@ -0,0 +1,163 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export const utilsContent = /* ts */ `
+import { bcs, BcsType, TypeTag, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple } from '@haneullabs/haneul/bcs';
+import { normalizeHaneulAddress } from '@haneullabs/haneul/utils';
+import { TransactionArgument, isArgument } from '@haneullabs/haneul/transactions';
+
+const MOVE_STDLIB_ADDRESS = normalizeHaneulAddress('0x1');
+const HANEUL_FRAMEWORK_ADDRESS = normalizeHaneulAddress('0x2');
+const HANEUL_SYSTEM_ADDRESS = normalizeHaneulAddress('0x3');
+
+export type RawTransactionArgument<T> = T | TransactionArgument;
+
+export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null {
+	const parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+
+	if ('u8' in parsedTag) {
+		return bcs.U8;
+	} else if ('u16' in parsedTag) {
+		return bcs.U16;
+	} else if ('u32' in parsedTag) {
+		return bcs.U32;
+	} else if ('u64' in parsedTag) {
+		return bcs.U64;
+	} else if ('u128' in parsedTag) {
+		return bcs.U128;
+	} else if ('u256' in parsedTag) {
+		return bcs.U256;
+	} else if ('address' in parsedTag) {
+		return bcs.Address;
+	} else if ('bool' in parsedTag) {
+		return bcs.Bool;
+	} else if ('vector' in parsedTag) {
+		const type = getPureBcsSchema(parsedTag.vector);
+		return type ? bcs.vector(type) : null;
+	} else if ('struct' in parsedTag) {
+		const structTag = parsedTag.struct;
+		const pkg = normalizeHaneulAddress(parsedTag.struct.address);
+
+		if (pkg === MOVE_STDLIB_ADDRESS) {
+			if (
+				(structTag.module === 'ascii' || structTag.module === 'string') &&
+				structTag.name === 'String'
+			) {
+				return bcs.String;
+			}
+
+			if (structTag.module === 'option' && structTag.name === 'Option') {
+				const type = getPureBcsSchema(structTag.typeParams[0]!);
+				return type ? bcs.option(type) : null;
+			}
+		}
+
+		if (pkg === HANEUL_FRAMEWORK_ADDRESS && structTag.module === 'Object' && structTag.name === 'ID') {
+			return bcs.Address;
+		}
+	}
+
+	return null;
+}
+
+export function normalizeMoveArguments(args: unknown[] | object, argTypes: string[], parameterNames?: string[]) {
+	const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+	if (parameterNames && argLen !== parameterNames.length) {
+		throw new Error(
+			\`Invalid number of arguments, expected \${parameterNames.length}, got \${argLen}\`,
+		);
+	}
+
+	const normalizedArgs: TransactionArgument[] = [];
+
+	let index = 0;
+	for (const [i, argType] of argTypes.entries()) {
+		if (argType === \`\${HANEUL_FRAMEWORK_ADDRESS}::deny_list::DenyList\`) {
+			normalizedArgs.push((tx) => tx.object.denyList());
+			continue;
+		}
+
+		if (argType === \`\${HANEUL_FRAMEWORK_ADDRESS}::random::Random\`) {
+			normalizedArgs.push((tx) => tx.object.random());
+			continue;
+		}
+
+		if (argType === \`\${HANEUL_FRAMEWORK_ADDRESS}::clock::Clock\`) {
+			normalizedArgs.push((tx) => tx.object.clock());
+			continue;
+		}
+
+		if (argType === \`\${HANEUL_SYSTEM_ADDRESS}::haneul_system::HaneulSystemState\`) {
+			normalizedArgs.push((tx) => tx.object.system());
+			continue;
+		}
+
+		let arg
+		if (Array.isArray(args)) {
+			if (index >= args.length) {
+				throw new Error(\`Invalid number of arguments, expected at least \${index + 1}, got \${args.length}\`);
+			}
+			arg = args[index];
+		} else {
+			if (!parameterNames) {
+				throw new Error(\`Expected arguments to be passed as an array\`);
+			}
+			const name = parameterNames[index];
+			arg = args[name as keyof typeof args];
+
+			if (arg === undefined) {
+				throw new Error(\`Parameter \${name} is required\`);
+			}
+		}
+
+		index += 1;
+
+		if (typeof arg === 'function' || isArgument(arg)) {
+			normalizedArgs.push(arg as TransactionArgument);
+			continue;
+		}
+
+		const type = argTypes[i]!;
+		const bcsType = getPureBcsSchema(type);
+
+		if (bcsType) {
+			const bytes = bcsType.serialize(arg as never);
+			normalizedArgs.push((tx) => tx.pure(bytes));
+			continue;
+		} else if (typeof arg === 'string') {
+			normalizedArgs.push((tx) => tx.object(arg));
+			continue;
+		}
+
+		throw new Error(\`Invalid argument \${stringify(arg)} for type \${type}\`);
+	}
+
+	return normalizedArgs;
+}
+
+export class MoveStruct<
+	T extends Record<string, BcsType<any>>,
+	const Name extends string = string,
+> extends BcsStruct<T, Name> {}
+
+export class MoveEnum<
+	T extends Record<string, BcsType<any> | null>,
+	const Name extends string,
+> extends BcsEnum<T, Name> {}
+
+export class MoveTuple<
+	T extends readonly BcsType<any>[],
+	const Name extends string,
+> extends BcsTuple<T, Name> {}
+
+function stringify(val: unknown) {
+	if (typeof val === 'object') {
+		return JSON.stringify(val, (val: unknown) => val);
+	}
+	if (typeof val === 'bigint') {
+		return val.toString();
+	}
+
+	return val;
+}
+`;

package/src/index.ts

@@ -0,0 +1,131 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { MoveModuleBuilder } from './move-module-builder.js';
+import { existsSync, statSync } from 'node:fs';
+import { utilsContent } from './generate-utils.js';
+import { parse } from 'toml';
+import type { PackageConfig } from './config.js';
+export { type HaneulCodegenConfig } from './config.js';
+
+export async function generateFromPackageSummary({
+	package: pkg,
+	prune,
+	outputDir,
+	privateMethods,
+}: {
+	package: PackageConfig;
+	prune: boolean;
+	outputDir: string;
+	privateMethods: 'none' | 'entry' | 'all';
+}) {
+	if (!pkg.path) {
+		throw new Error(`On-chain packages are not supported yet (got ${pkg.package})`);
+	}
+
+	const summaryDir = join(pkg.path, 'package_summaries');
+
+	if (!existsSync(summaryDir)) {
+		throw new Error(`Package summary directory not found: ${summaryDir}`);
+	}
+
+	let packageName = pkg.packageName!;
+	const mvrNameOrAddress = pkg.package;
+
+	if (!pkg.packageName) {
+		try {
+			const packageToml = await readFile(join(pkg.path, 'Move.toml'), 'utf-8');
+			packageName = parse(packageToml).package.name.toLowerCase();
+		} catch {
+			const message = `Package name not found in package.toml for ${pkg.path}`;
+			if (packageName) {
+				console.warn(message);
+			} else {
+				throw new Error(message);
+			}
+		}
+	}
+
+	if (!existsSync(summaryDir)) {
+		throw new Error(`Package summary directory not found: ${summaryDir}`);
+	}
+
+	const addressMappings: Record<string, string> = JSON.parse(
+		await readFile(join(summaryDir, 'address_mapping.json'), 'utf-8'),
+	);
+
+	const packages = (await readdir(summaryDir)).filter((file) =>
+		statSync(join(summaryDir, file)).isDirectory(),
+	);
+	const modules = (
+		await Promise.all(
+			packages.map(async (pkg) => {
+				const modules = await readdir(join(summaryDir, pkg));
+				return Promise.all(
+					modules.map(async (mod) => ({
+						package: pkg,
+						isMainPackage: pkg === packageName,
+						module: basename(mod, '.json'),
+						builder: await MoveModuleBuilder.fromSummaryFile(
+							join(summaryDir, pkg, mod),
+							addressMappings,
+							pkg === packageName ? mvrNameOrAddress : undefined,
+						),
+					})),
+				);
+			}),
+		)
+	).flat();
+
+	const moduleBuilders = Object.fromEntries(
+		modules.map((mod) => [`${mod.package}::${mod.module}`, mod.builder]),
+	);
+
+	modules.forEach((mod) => {
+		if (mod.isMainPackage || !prune) {
+			mod.builder.includeAllTypes(moduleBuilders);
+			mod.builder.includeAllFunctions({ privateMethods });
+		}
+	});
+
+	await generateUtils({ outputDir });
+
+	await Promise.all(
+		modules.map(async (mod) => {
+			if ((mod.isMainPackage || !prune) && mod.builder.hasTypesOrFunctions()) {
+				await mod.builder.renderBCSTypes();
+				await mod.builder.renderFunctions();
+			} else if (mod.isMainPackage) {
+				return;
+			} else if (mod.builder.hasBcsTypes()) {
+				await mod.builder.renderBCSTypes();
+			} else {
+				return;
+			}
+
+			await mkdir(
+				mod.isMainPackage
+					? join(outputDir, packageName)
+					: join(outputDir, packageName, 'deps', mod.package),
+				{ recursive: true },
+			);
+
+			await writeFile(
+				mod.isMainPackage
+					? join(outputDir, packageName, `${mod.module}.ts`)
+					: join(outputDir, packageName, 'deps', mod.package, `${mod.module}.ts`),
+				await mod.builder.toString(
+					'./',
+					mod.isMainPackage ? `./${mod.module}.ts` : `./deps/${mod.package}/${mod.module}.ts`,
+				),
+			);
+		}),
+	);
+}
+
+async function generateUtils({ outputDir }: { outputDir: string }) {
+	await mkdir(join(outputDir, 'utils'), { recursive: true });
+	await writeFile(join(outputDir, 'utils', 'index.ts'), utilsContent);
+}