@haneullabs/codegen 0.1.0

package/src/render-types.ts

@@ -0,0 +1,349 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { normalizeHaneulAddress } from '@haneullabs/haneul/utils';
+
+import type { Datatype, ModuleSummary, Type, TypeParameter } from './types/summary.js';
+
+export const MOVE_STDLIB_ADDRESS = normalizeHaneulAddress('0x1');
+export const HANEUL_FRAMEWORK_ADDRESS = normalizeHaneulAddress('0x2');
+export const HANEUL_SYSTEM_ADDRESS = normalizeHaneulAddress('0x3');
+
+type TypeSignatureFormat = 'typescriptArg' | 'bcs' | 'typeTag';
+interface RenderTypeSignatureOptions {
+	format: TypeSignatureFormat;
+	summary: ModuleSummary;
+	typeParameters?: TypeParameter[];
+	onDependency?: (address: string, module: string, type: string) => string | undefined;
+	onBcsType?: () => void;
+	onTypeParameter?: (typeParameter: number | string) => void;
+	resolveAddress: (address: string) => string;
+}
+
+export function renderTypeSignature(type: Type, options: RenderTypeSignatureOptions): string {
+	if (options.onBcsType) {
+		if (usesBcs(type, options)) {
+			options.onBcsType();
+		}
+	}
+
+	switch (type) {
+		case 'address':
+			switch (options.format) {
+				case 'typescriptArg':
+					return 'string';
+				case 'typeTag':
+					return `address`;
+				case 'bcs':
+					return 'bcs.Address';
+				default:
+					throw new Error(`Unknown format: ${options.format}`);
+			}
+		case 'bool':
+			switch (options.format) {
+				case 'typescriptArg':
+					return 'boolean';
+				case 'typeTag':
+					return `bool`;
+				case 'bcs':
+					return 'bcs.bool()';
+				default:
+					throw new Error(`Unknown format: ${options.format}`);
+			}
+		case 'u8':
+		case 'u16':
+		case 'u32':
+			switch (options.format) {
+				case 'typescriptArg':
+					return 'number';
+				case 'typeTag':
+					return type.toLowerCase();
+				case 'bcs':
+					return `bcs.${type.toLowerCase()}()`;
+				default:
+					throw new Error(`Unknown format: ${options.format}`);
+			}
+		case 'u64':
+		case 'u128':
+		case 'u256':
+			switch (options.format) {
+				case 'typescriptArg':
+					return `number | bigint`;
+				case 'typeTag':
+					return type.toLowerCase();
+				case 'bcs':
+					return `bcs.${type.toLowerCase()}()`;
+				default:
+					throw new Error(`Unknown format: ${options.format}`);
+			}
+		case 'signer':
+			throw new Error('Signer is not supported');
+		case '_':
+			throw new Error('Macro placeholder is not supported');
+	}
+
+	if ('Datatype' in type) {
+		return renderDataType(type.Datatype, options);
+	}
+
+	if ('Reference' in type) {
+		return renderTypeSignature(type.Reference[1], options);
+	}
+
+	if ('vector' in type) {
+		switch (options.format) {
+			case 'typescriptArg':
+				return `${renderTypeSignature(type.vector, options)}[]`;
+			case 'typeTag':
+				return `vector<${renderTypeSignature(type.vector, options)}>`;
+			case 'bcs':
+				return `bcs.vector(${renderTypeSignature(type.vector, options)})`;
+			default:
+				throw new Error(`Unknown format: ${options.format}`);
+		}
+	}
+
+	if ('TypeParameter' in type) {
+		options.onTypeParameter?.(type.TypeParameter);
+		switch (options.format) {
+			case 'typescriptArg':
+				return options.typeParameters?.[type.TypeParameter]?.name ?? `T${type.TypeParameter}`;
+			case 'typeTag':
+				return `\${options.typeArguments[${type.TypeParameter}]}`;
+			case 'bcs':
+				return `typeParameters[${type.TypeParameter}]`;
+			default:
+				throw new Error(`Unknown format: ${options.format}`);
+		}
+	}
+
+	if ('NamedTypeParameter' in type) {
+		options.onTypeParameter?.(type.NamedTypeParameter);
+		const index =
+			options.typeParameters?.findIndex((p) => p.name === type.NamedTypeParameter) ?? -1;
+
+		if (index === -1) {
+			throw new Error(`Named type parameter ${type.NamedTypeParameter} not found`);
+		}
+
+		switch (options.format) {
+			case 'typescriptArg':
+				return type.NamedTypeParameter;
+			case 'typeTag':
+				return `\${options.typeArguments[${index}]}`;
+			case 'bcs':
+				return `typeParameters[${index}]`;
+			default:
+				throw new Error(`Unknown format: ${options.format}`);
+		}
+	}
+
+	throw new Error(`Unknown type signature: ${JSON.stringify(type, null, 2)}`);
+}
+
+export function usesBcs(type: Type, options: RenderTypeSignatureOptions): boolean {
+	if (typeof type === 'string') {
+		return true;
+	}
+
+	if ('Reference' in type) {
+		return usesBcs(type.Reference[1], options);
+	}
+
+	if ('Datatype' in type) {
+		return isPureDataType(type.Datatype, options);
+	}
+
+	if ('vector' in type) {
+		return true;
+	}
+
+	return false;
+}
+
+export function isPureSignature(type: Type, options: RenderTypeSignatureOptions): boolean {
+	if (typeof type === 'string') {
+		return true;
+	}
+
+	if ('Reference' in type) {
+		return isPureSignature(type.Reference[1], options);
+	}
+
+	if ('Datatype' in type) {
+		return isPureDataType(type.Datatype, options);
+	}
+
+	if ('vector' in type) {
+		return isPureSignature(type.vector, options);
+	}
+
+	if ('TypeParameter' in type) {
+		return false;
+	}
+
+	if ('NamedTypeParameter' in type) {
+		return false;
+	}
+
+	throw new Error(`Unknown type signature: ${JSON.stringify(type, null, 2)}`);
+}
+
+function isPureDataType(type: Datatype, options: RenderTypeSignatureOptions) {
+	const address = options.resolveAddress(type.module.address);
+
+	if (address === MOVE_STDLIB_ADDRESS) {
+		if ((type.module.name === 'ascii' || type.module.name === 'string') && type.name === 'String') {
+			return true;
+		}
+
+		if (type.module.name === 'option' && type.name === 'Option') {
+			return true;
+		}
+	}
+
+	if (address === HANEUL_FRAMEWORK_ADDRESS) {
+		if (type.module.name === 'object' && type.name === 'ID') {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function renderDataType(type: Datatype, options: RenderTypeSignatureOptions): string {
+	const address = options.resolveAddress(type.module.address);
+
+	if (options.format === 'typeTag') {
+		const typeArgs = type.type_arguments.map((type) => renderTypeSignature(type.argument, options));
+
+		if (typeArgs.length === 0) {
+			// eslint-disable-next-line no-template-curly-in-string
+			return `${address === options.resolveAddress(options.summary.id.address) ? '${packageAddress}' : address}::${type.module.name}::${type.name}`;
+		}
+
+		// eslint-disable-next-line no-template-curly-in-string
+		return `${address === options.resolveAddress(options.summary.id.address) ? '${packageAddress}' : address}::${type.module.name}::${type.name}<${typeArgs.join(', ')}>`;
+	}
+
+	if (address === MOVE_STDLIB_ADDRESS) {
+		if ((type.module.name === 'ascii' || type.module.name === 'string') && type.name === 'String') {
+			switch (options.format) {
+				case 'typescriptArg':
+					return 'string';
+				case 'bcs':
+					return 'bcs.string()';
+				default:
+					throw new Error(`Unknown format: ${options.format}`);
+			}
+		}
+
+		if (type.module.name === 'option' && type.name === 'Option') {
+			switch (options.format) {
+				case 'typescriptArg':
+					if (isPureDataType(type, options)) {
+						return `${renderTypeSignature(type.type_arguments[0].argument, options)} | null`;
+					}
+					break;
+				case 'bcs':
+					return `bcs.option(${renderTypeSignature(type.type_arguments[0].argument, options)})`;
+				default:
+					throw new Error(`Unknown format: ${options.format}`);
+			}
+		}
+	}
+
+	if (address === HANEUL_FRAMEWORK_ADDRESS) {
+		if (type.module.name === 'object' && type.name === 'ID') {
+			switch (options.format) {
+				case 'typescriptArg':
+					return 'string';
+				case 'bcs':
+					return 'bcs.Address';
+				default:
+					throw new Error(`Unknown format: ${options.format}`);
+			}
+		}
+	}
+
+	const isCurrentModule =
+		address === options.resolveAddress(options.summary.id.address) &&
+		type.module.name === options.summary.id.name;
+
+	const importName = options.onDependency?.(type.module.address, type.module.name, type.name);
+
+	const typeNameRef = isCurrentModule
+		? type.name
+		: `${importName ?? getSafeName(type.module.name)}.${getSafeName(type.name)}`;
+
+	const filteredTypeArguments = type.type_arguments.filter((arg) => !arg.phantom);
+
+	switch (options.format) {
+		case 'typescriptArg':
+			return 'string';
+		case 'bcs':
+			if (filteredTypeArguments.length === 0) {
+				return typeNameRef;
+			}
+
+			return `${typeNameRef}(
+                ${filteredTypeArguments.map((type) => renderTypeSignature(type.argument, options)).join(', ')})`;
+		default:
+			throw new Error(`Unknown format: ${options.format}`);
+	}
+}
+
+const JS_RESERVED_NAMES = [
+	'new',
+	'delete',
+	'class',
+	'function',
+	'import',
+	'export',
+	'return',
+	'this',
+	'super',
+	'arguments',
+	'eval',
+	'void',
+	'typeof',
+	'instanceof',
+	'delete',
+	'in',
+	'from',
+	'of',
+	'as',
+	'async',
+	'await',
+	'break',
+	'case',
+	'catch',
+	'continue',
+	'debugger',
+	'default',
+	'do',
+	'else',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'import',
+	'in',
+	'instanceof',
+	'new',
+	'return',
+	'switch',
+	'throw',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'yield',
+	'package',
+];
+
+export function getSafeName(name: string) {
+	return JS_RESERVED_NAMES.includes(name) ? `_${name}` : name;
+}

package/src/summary.ts

@@ -0,0 +1,242 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { normalizeHaneulAddress } from '@haneullabs/haneul/utils';
+import type { DeserializedModule, TypeSignature } from './types/deserialized.js';
+import type {
+	EnumSummary,
+	Field,
+	FunctionSummary,
+	ModuleSummary,
+	StructSummary,
+	Type,
+	Variant,
+} from './types/summary.js';
+
+export function summaryFromDeserializedModule(mod: DeserializedModule) {
+	const moduleHandle = mod.module_handles[mod.self_module_handle_idx];
+	const summary: ModuleSummary = {
+		id: {
+			address: normalizeHaneulAddress(mod.address_identifiers[moduleHandle.address]),
+			name: mod.identifiers[moduleHandle.name],
+		},
+		immediate_dependencies: mod.module_handles.map((m) => ({
+			address: normalizeHaneulAddress(mod.address_identifiers[m.address]),
+			name: mod.identifiers[m.name],
+		})),
+		functions: Object.fromEntries(
+			Array.from({ length: mod.function_defs.length }, (_, i) =>
+				functionSummaryFromDeserializedFunction(mod, i),
+			),
+		),
+		structs: Object.fromEntries(
+			Array.from({ length: mod.struct_defs.length }, (_, i) =>
+				structSummaryFromDeserializedStruct(mod, i),
+			),
+		),
+		enums: Object.fromEntries(
+			Array.from({ length: mod.enum_defs.length }, (_, i) =>
+				enumSummaryFromDeserializedEnum(mod, i),
+			),
+		),
+	};
+
+	return summary;
+}
+
+function functionSummaryFromDeserializedFunction(mod: DeserializedModule, index: number) {
+	const def = mod.function_defs[index];
+	const handle = mod.function_handles[def.function];
+	const name = mod.identifiers[handle.name];
+
+	const functionSummary: FunctionSummary = {
+		index,
+		visibility: def.visibility,
+		entry: def.is_entry,
+		type_parameters: handle.type_parameters.map((p) => {
+			return {
+				phantom: p.is_phantom,
+				constraints: [],
+			};
+		}),
+		parameters: mod.signatures[handle.parameters].map((type) => ({
+			type_: typeFromTypeSignature(mod, type),
+		})),
+		return_: mod.signatures[handle.return_].map((type) => typeFromTypeSignature(mod, type)),
+	};
+
+	return [name, functionSummary];
+}
+
+function structSummaryFromDeserializedStruct(mod: DeserializedModule, index: number) {
+	const def = mod.struct_defs[index];
+	const handle = mod.datatype_handles[def.struct_handle];
+	const name = mod.identifiers[handle.name];
+
+	const structSummary: StructSummary = {
+		index,
+		abilities: [],
+		type_parameters: handle.type_parameters.map((p) => {
+			return {
+				phantom: p.is_phantom,
+				constraints: [],
+			};
+		}),
+		fields: {
+			positional_fields: false,
+			fields: Object.fromEntries(
+				(def.field_information.Declared ?? []).map((field) =>
+					fieldSummaryFromDeserializedField(mod, field),
+				),
+			),
+		},
+	};
+
+	return [name, structSummary];
+}
+
+function enumSummaryFromDeserializedEnum(mod: DeserializedModule, index: number) {
+	const def = mod.enum_defs[index];
+	const handle = mod.datatype_handles[def.enum_handle];
+	const name = mod.identifiers[handle.name];
+
+	const enumSummary: EnumSummary = {
+		index,
+		abilities: [],
+		type_parameters: handle.type_parameters.map((p) => {
+			return {
+				phantom: p.is_phantom,
+				constraints: [],
+			};
+		}),
+		variants: Object.fromEntries(
+			def.variants.map((variant) => variantSummaryFromDeserializedVariant(mod, variant)),
+		),
+	};
+
+	return [name, enumSummary];
+}
+
+function variantSummaryFromDeserializedVariant(
+	mod: DeserializedModule,
+	variant: {
+		variant_name: number;
+		fields: Array<{
+			name: number;
+			signature: TypeSignature;
+		}>;
+	},
+): [string, Variant] {
+	return [
+		mod.identifiers[variant.variant_name],
+		{
+			index: variant.variant_name,
+			fields: {
+				positional_fields: false,
+				fields: Object.fromEntries(
+					variant.fields.map((field) => fieldSummaryFromDeserializedField(mod, field)),
+				),
+			},
+		},
+	];
+}
+
+function fieldSummaryFromDeserializedField(
+	mod: DeserializedModule,
+	declared: {
+		name: number;
+		signature: TypeSignature;
+	},
+) {
+	const name = mod.identifiers[declared.name];
+	const type = typeFromTypeSignature(mod, declared.signature);
+
+	const field: Field = {
+		index: declared.name,
+		type_: type,
+	};
+
+	return [name, field];
+}
+
+function typeFromTypeSignature(mod: DeserializedModule, type: TypeSignature): Type {
+	switch (type) {
+		case 'U8':
+			return 'u8';
+		case 'U16':
+			return 'u16';
+		case 'U32':
+			return 'u32';
+		case 'U64':
+			return 'u64';
+		case 'U128':
+			return 'u128';
+		case 'U256':
+			return 'u256';
+		case 'Address':
+			return 'address';
+		case 'Bool':
+			return 'bool';
+	}
+
+	if ('Datatype' in type) {
+		const handle = mod.datatype_handles[type.Datatype];
+		const module = mod.module_handles[handle.module];
+		return {
+			Datatype: {
+				module: {
+					address: normalizeHaneulAddress(mod.address_identifiers[module.address]),
+					name: mod.identifiers[module.name],
+				},
+				name: mod.identifiers[handle.name],
+				type_arguments: [],
+			},
+		};
+	}
+
+	if ('DatatypeInstantiation' in type) {
+		const handle = mod.datatype_handles[type.DatatypeInstantiation[0]];
+		const module = mod.module_handles[handle.module];
+		return {
+			Datatype: {
+				module: {
+					address: normalizeHaneulAddress(mod.address_identifiers[module.address]),
+					name: mod.identifiers[module.name],
+				},
+				name: mod.identifiers[handle.name],
+				type_arguments: type.DatatypeInstantiation[1].map((t, i) => {
+					return {
+						phantom: handle.type_parameters[i].is_phantom,
+						argument: typeFromTypeSignature(mod, t),
+					};
+				}),
+			},
+		};
+	}
+
+	if ('Vector' in type) {
+		return {
+			vector: typeFromTypeSignature(mod, type.Vector),
+		};
+	}
+
+	if ('TypeParameter' in type) {
+		return {
+			TypeParameter: type.TypeParameter,
+		};
+	}
+
+	if ('Reference' in type) {
+		return {
+			Reference: [false, typeFromTypeSignature(mod, type.Reference)],
+		};
+	}
+
+	if ('MutableReference' in type) {
+		return {
+			Reference: [true, typeFromTypeSignature(mod, type.MutableReference)],
+		};
+	}
+
+	throw new Error(`Unknown type: ${type}`);
+}

package/src/types/deserialized.ts

@@ -0,0 +1,107 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export type TypeSignature =
+	| 'U8'
+	| 'U16'
+	| 'U32'
+	| 'U64'
+	| 'U128'
+	| 'U256'
+	| 'Address'
+	| 'Bool'
+	| {
+			Datatype: number;
+	  }
+	| {
+			DatatypeInstantiation: [number, TypeSignature[]];
+	  }
+	| {
+			Vector: TypeSignature;
+	  }
+	| {
+			TypeParameter: number;
+	  }
+	| {
+			Reference: TypeSignature;
+	  }
+	| {
+			MutableReference: TypeSignature;
+	  };
+
+export interface DeserializedModule {
+	version: number;
+	self_module_handle_idx: number;
+	module_handles: Array<{
+		name: number;
+		address: number;
+	}>;
+	datatype_handles: Array<{
+		name: number;
+		module: number;
+		abilities: number;
+		type_parameters: Array<{
+			constraints: number;
+			is_phantom: boolean;
+		}>;
+	}>;
+	function_handles: Array<{
+		module: number;
+		name: number;
+		parameters: number;
+		return_: number;
+		type_parameters: Array<{
+			constraints: number;
+			is_phantom: boolean;
+		}>;
+	}>;
+	field_handles: Array<{
+		owner: number;
+		field: number;
+	}>;
+	friend_decls: Array<unknown>;
+	struct_def_instantiations: Array<unknown>;
+	function_instantiations: Array<unknown>;
+	field_instantiations: Array<unknown>;
+	signatures: Array<Array<TypeSignature>>;
+	identifiers: Array<string>;
+	address_identifiers: Array<string>;
+	constant_pool: Array<{
+		type_: TypeSignature;
+		data: Array<number>;
+	}>;
+	metadata: Array<unknown>;
+	struct_defs: Array<{
+		struct_handle: number;
+		field_information: {
+			Declared?: Array<{
+				name: number;
+				signature: TypeSignature;
+			}>;
+		};
+	}>;
+	function_defs: Array<{
+		function: number;
+		visibility: 'Public' | 'Private' | 'Friend';
+		is_entry: boolean;
+		acquires_global_resources: Array<unknown>;
+		flags: number;
+		code: unknown;
+	}>;
+	enum_defs: Array<{
+		enum_handle: number;
+		variants: Array<{
+			variant_name: number;
+			fields: Array<{
+				name: number;
+				signature: TypeSignature;
+			}>;
+		}>;
+	}>;
+	enum_def_instantiations: Array<unknown>;
+	variant_handles: Array<{
+		enum_def: number;
+		variant: number;
+	}>;
+	variant_instantiation_handles: Array<unknown>;
+}