@haneullabs/haneulns 1.0.2 → 1.2.5

package/src/contracts/utils/index.ts

@@ -1,32 +1,26 @@
 import {
 	bcs,
-	BcsType,
-	TypeTag,
+	type BcsType,
+	type TypeTag,
 	TypeTagSerializer,
 	BcsStruct,
 	BcsEnum,
 	BcsTuple,
 } from '@haneullabs/haneul/bcs';
-import { normalizeHaneulAddress } from '@haneullabs/haneul/utils';
-import { TransactionArgument, isArgument } from '@haneullabs/haneul/transactions';
-import { ClientWithCoreApi, HaneulClientTypes } from '@haneullabs/haneul/client';
+import { normalizeStructTag, normalizeHaneulAddress } from '@haneullabs/haneul/utils';
+import { type TransactionArgument, isArgument } from '@haneullabs/haneul/transactions';
+import { type ClientWithCoreApi, type HaneulClientTypes } from '@haneullabs/haneul/client';
 
 const MOVE_STDLIB_ADDRESS = normalizeHaneulAddress('0x1');
 const HANEUL_FRAMEWORK_ADDRESS = normalizeHaneulAddress('0x2');
 
 export type RawTransactionArgument<T> = T | TransactionArgument;
 
-export interface GetOptions<
-	Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {},
-> extends HaneulClientTypes.GetObjectOptions<Include> {
-	client: ClientWithCoreApi;
-}
+export type GetOptions<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {}> =
+	HaneulClientTypes.GetObjectOptions<Include> & { client: ClientWithCoreApi };
 
-export interface GetManyOptions<
-	Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {},
-> extends HaneulClientTypes.GetObjectsOptions<Include> {
-	client: ClientWithCoreApi;
-}
+export type GetManyOptions<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {}> =
+	HaneulClientTypes.GetObjectsOptions<Include> & { client: ClientWithCoreApi };
 
 export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null {
 	const parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
@@ -63,7 +57,8 @@ export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null
 			}
 
 			if (structTag.module === 'option' && structTag.name === 'Option') {
-				const type = getPureBcsSchema(structTag.typeParams[0]);
+				const inner = structTag.typeParams[0];
+				const type = inner ? getPureBcsSchema(inner) : null;
 				return type ? bcs.option(type) : null;
 			}
 		}
@@ -95,7 +90,7 @@ export function normalizeMoveArguments(
 	const normalizedArgs: TransactionArgument[] = [];
 
 	let index = 0;
-	for (const [i, argType] of argTypes.entries()) {
+	for (const argType of argTypes) {
 		if (argType === '0x2::clock::Clock') {
 			normalizedArgs.push((tx) => tx.object.clock());
 			continue;
@@ -143,28 +138,162 @@ export function normalizeMoveArguments(
 			continue;
 		}
 
-		const type = argTypes[i];
-		const bcsType = type === null ? null : getPureBcsSchema(type);
+		const bcsType = argType === null ? null : getPureBcsSchema(argType);
 
 		if (bcsType) {
 			const bytes = bcsType.serialize(arg as never);
 			normalizedArgs.push((tx) => tx.pure(bytes));
 			continue;
-		} else if (typeof arg === 'string') {
+		}
+
+		if (typeof arg === 'string') {
 			normalizedArgs.push((tx) => tx.object(arg));
 			continue;
 		}
 
-		throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+		throw new Error(`Invalid argument ${stringify(arg)} for type ${argType}`);
 	}
 
 	return normalizedArgs;
 }
 
+/* -------------------------- Move type tags -------------------------- */
+
+/** A type argument: a type tag string, or a BCS type whose name is a Move type. */
+export type TypeArgument = string | BcsType<any>;
+
+export interface TypeTagOptions {
+	package?: string;
+	typeArguments?: readonly TypeArgument[];
+}
+
+/**
+ * `typeArguments` is required when the type's name contains unfilled
+ * `phantom X` parameters (at any depth). Everything else — argument arity,
+ * position contents, and tag validity — is validated at runtime.
+ */
+type TypeTagParams<Name extends string> = Name extends `${string}phantom ${string}`
+	? [options: TypeTagOptions & { typeArguments: readonly TypeArgument[] }]
+	: [options?: TypeTagOptions];
+
+type ResolveTypeTagOptions<Name extends string> = {
+	client: ClientWithCoreApi;
+} & (Name extends `${string}phantom ${string}`
+	? TypeTagOptions & { typeArguments: readonly TypeArgument[] }
+	: TypeTagOptions);
+
+const HAS_PHANTOM_REGEX = /phantom [A-Za-z_$][A-Za-z0-9_$]*/;
+
+function splitTopLevelTypeArgs(inner: string): string[] {
+	const parts: string[] = [];
+	let depth = 0;
+	let current = '';
+	for (const char of inner) {
+		if (char === ',' && depth === 0) {
+			parts.push(current.trim());
+			current = '';
+			continue;
+		}
+		if (char === '<') depth++;
+		if (char === '>') depth--;
+		current += char;
+	}
+	if (current) parts.push(current.trim());
+	return parts;
+}
+
+function buildTypeTag(name: string, options: TypeTagOptions | undefined): string {
+	const lt = name.indexOf('<');
+	const base = lt === -1 ? name : name.slice(0, lt);
+
+	if (base.split('::').length !== 3) {
+		throw new Error(`${name} is not a top-level Move type`);
+	}
+
+	let result = name;
+
+	if (options?.typeArguments) {
+		const baked = lt === -1 ? [] : splitTopLevelTypeArgs(name.slice(lt + 1, -1));
+		const supplied = options.typeArguments.map((arg) => {
+			if (typeof arg === 'string') {
+				return arg;
+			}
+			if (arg && typeof arg.serialize === 'function' && typeof arg.name === 'string') {
+				return arg.name;
+			}
+			throw new Error(`Invalid type argument ${stringify(arg)}`);
+		});
+
+		if (supplied.length !== baked.length) {
+			throw new Error(
+				`Expected ${baked.length} type arguments for ${base}, got ${supplied.length}`,
+			);
+		}
+
+		result = supplied.length === 0 ? base : `${base}<${supplied.join(', ')}>`;
+	}
+
+	if (HAS_PHANTOM_REGEX.test(result)) {
+		throw new Error(
+			options?.typeArguments
+				? `A type argument contains an unfilled phantom parameter in ${result}`
+				: `Missing type arguments for ${result}`,
+		);
+	}
+
+	if (options?.package) {
+		const [, ...rest] = result.split('::');
+		result = [options.package, ...rest].join('::');
+	}
+
+	// fully validate address-only tags (MVR names can't be parsed as type tags)
+	if (!HAS_PHANTOM_REGEX.test(result) && !/[@/]/.test(result)) {
+		TypeTagSerializer.parseFromStr(result);
+	}
+
+	return result;
+}
+
+async function resolveBuiltTypeTag(
+	name: string,
+	options: { client: ClientWithCoreApi } & TypeTagOptions,
+): Promise<string> {
+	const { client, ...rest } = options;
+	const { type } = await client.core.mvr.resolveType({
+		type: buildTypeTag(name, rest),
+	});
+	return normalizeStructTag(type);
+}
+
 export class MoveStruct<
 	T extends Record<string, BcsType<any>>,
 	const Name extends string = string,
 > extends BcsStruct<T, Name> {
+	/**
+	 * Build the type tag for this struct.
+	 *
+	 * `typeArguments` is the full positional list, in Move declaration order, and
+	 * is required when the struct has unfilled phantom parameters. The result may
+	 * contain MVR names: those are valid in transaction `typeArguments`, but for
+	 * queries or comparisons against on-chain data use `resolveTypeTag` instead.
+	 */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/**
+	 * Build the type tag for this struct, then resolve any MVR names through the
+	 * client (using its configured overrides and the MVR API) and return the
+	 * normalized, address-only form suitable for queries and comparisons against
+	 * on-chain data.
+	 */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(
+			this.name,
+			options as { client: ClientWithCoreApi } & TypeTagOptions,
+		);
+	}
+
 	async get<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
 		objectId,
 		...options
@@ -178,6 +307,10 @@ export class MoveStruct<
 			objectIds: [objectId],
 		});
 
+		if (!res) {
+			throw new Error(`No object found for id ${objectId}`);
+		}
+
 		return res;
 	}
 
@@ -215,16 +348,44 @@ export class MoveStruct<
 export class MoveEnum<
 	T extends Record<string, BcsType<any> | null>,
 	const Name extends string,
-> extends BcsEnum<T, Name> {}
+> extends BcsEnum<T, Name> {
+	/** Build the type tag for this enum. See `MoveStruct.typeTag` for semantics. */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/** Build and resolve the type tag for this enum. See `MoveStruct.resolveTypeTag`. */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(
+			this.name,
+			options as { client: ClientWithCoreApi } & TypeTagOptions,
+		);
+	}
+}
 
 export class MoveTuple<
 	const T extends readonly BcsType<any>[],
 	const Name extends string,
-> extends BcsTuple<T, Name> {}
+> extends BcsTuple<T, Name> {
+	/** Build the type tag for this struct. See `MoveStruct.typeTag` for semantics. */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/** Build and resolve the type tag for this struct. See `MoveStruct.resolveTypeTag`. */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(
+			this.name,
+			options as { client: ClientWithCoreApi } & TypeTagOptions,
+		);
+	}
+}
 
 function stringify(val: unknown) {
 	if (typeof val === 'object') {
-		return JSON.stringify(val, (val: unknown) => val);
+		return JSON.stringify(val, (_key, value) =>
+			typeof value === 'bigint' ? value.toString() : value,
+		);
 	}
 	if (typeof val === 'bigint') {
 		return val.toString();

package/src/haneulns-client.ts

@@ -11,8 +11,8 @@ import type {
 	CoinTypeDiscount,
 	NameRecord,
 	PackageInfo,
-	SuinsClientConfig,
-	SuinsPriceList,
+	HaneulnsClientConfig,
+	HaneulnsPriceList,
 } from './types.js';
 
 import { ConfigKey } from './contracts/haneulns/haneulns.js';
@@ -21,7 +21,7 @@ import { NameRecord as NameRecordBcs } from './contracts/haneulns/name_record.js
 import { PricingConfig, RenewalConfig } from './contracts/haneulns/pricing_config.js';
 import { PaymentsConfig } from './contracts/haneulns_payments/payments.js';
 
-export type SuinsExtensionOptions<Name extends string = 'haneulns'> = {
+export type HaneulnsExtensionOptions<Name extends string = 'haneulns'> = {
 	name?: Name;
 	packageInfo?: PackageInfo;
 };
@@ -45,11 +45,11 @@ export type SuinsExtensionOptions<Name extends string = 'haneulns'> = {
 export function haneulns<const Name extends string = 'haneulns'>({
 	name = 'haneulns' as Name,
 	packageInfo,
-}: SuinsExtensionOptions<Name> = {}) {
+}: HaneulnsExtensionOptions<Name> = {}) {
 	return {
 		name,
 		register: (client: ClientWithCoreApi) => {
-			return new SuinsClient({
+			return new HaneulnsClient({
 				client,
 				network: client.network,
 				packageInfo,
@@ -58,12 +58,12 @@ export function haneulns<const Name extends string = 'haneulns'>({
 	};
 }
 
-export class SuinsClient {
+export class HaneulnsClient {
 	client: ClientWithCoreApi;
 	network: HaneulClientTypes.Network;
 	config: PackageInfo;
 
-	constructor(config: SuinsClientConfig) {
+	constructor(config: HaneulnsClientConfig) {
 		this.client = config.client;
 		this.network = config.network || 'mainnet';
 
@@ -88,8 +88,8 @@ export class SuinsClient {
 	// 	[ 4, 4 ] => 100000000,
 	// 	[ 5, 63 ] => 20000000
 	// }
-	async getPriceList(): Promise<SuinsPriceList> {
-		if (!this.config.haneulns) throw new Error('Suins object ID is not set');
+	async getPriceList(): Promise<HaneulnsPriceList> {
+		if (!this.config.haneulns) throw new Error('Haneulns object ID is not set');
 		if (!this.config.packageId) throw new Error('Price list config not found');
 
 		const configType = `${this.config.packageIdV1}::haneulns::ConfigKey<${this.config.packageIdPricing}::pricing_config::PricingConfig>`;
@@ -126,8 +126,8 @@ export class SuinsClient {
 	// 	[ 4, 4 ] => 100000000,
 	// 	[ 5, 63 ] => 20000000
 	// }
-	async getRenewalPriceList(): Promise<SuinsPriceList> {
-		if (!this.config.haneulns) throw new Error('Suins object ID is not set');
+	async getRenewalPriceList(): Promise<HaneulnsPriceList> {
+		if (!this.config.haneulns) throw new Error('Haneulns object ID is not set');
 		if (!this.config.packageId) throw new Error('Price list config not found');
 
 		const configType = `${this.config.packageIdV1}::haneulns::ConfigKey<${this.config.packageIdPricing}::pricing_config::RenewalConfig>`;
@@ -165,7 +165,7 @@ export class SuinsClient {
 	// 	'b48aac3f53bab328e1eb4c5b3c34f55e760f2fb3f2305ee1a474878d80f650f0::TESTNS::TESTNS' => 25
 	// }
 	async getCoinTypeDiscount(): Promise<CoinTypeDiscount> {
-		if (!this.config.haneulns) throw new Error('Suins object ID is not set');
+		if (!this.config.haneulns) throw new Error('Haneulns object ID is not set');
 		if (!this.config.packageId) throw new Error('Price list config not found');
 
 		const configType = `${this.config.packageIdV1}::haneulns::ConfigKey<${this.config.payments.packageId}::payments::PaymentsConfig>`;
@@ -193,7 +193,7 @@ export class SuinsClient {
 
 	async getNameRecord(name: string): Promise<NameRecord | null> {
 		if (!isValidHaneulNSName(name)) throw new Error('Invalid HaneulNS name');
-		if (!this.config.registryTableId) throw new Error('Suins package ID is not set');
+		if (!this.config.registryTableId) throw new Error('Haneulns package ID is not set');
 
 		const labels = normalizeHaneulNSName(name, 'dot').split('.').reverse();
 
@@ -232,7 +232,7 @@ export class SuinsClient {
 
 	/**
 	 * Calculates the registration or renewal price for an SLD (Second Level Domain).
-	 * It expects a domain name, the number of years and a `SuinsPriceList` object,
+	 * It expects a domain name, the number of years and a `HaneulnsPriceList` object,
 	 * as returned from `haneulnsClient.getPriceList()` function, or `haneulns.getRenewalPriceList()` function.
 	 *
 	 * It throws an error:

package/src/haneulns-transaction.ts

@@ -11,7 +11,7 @@ import { isValidHaneulNSName, normalizeHaneulNSName, HANEUL_CLOCK_OBJECT_ID } fr
 
 import { ALLOWED_METADATA, MAX_U64 } from './constants.js';
 import { isNestedSubName, isSubName, zeroCoin } from './helpers.js';
-import type { SuinsClient } from './haneulns-client.js';
+import type { HaneulnsClient } from './haneulns-client.js';
 import type { DiscountInfo, ReceiptParams, RegistrationParams, RenewalParams } from './types.js';
 
 import * as payment from './contracts/haneulns/payment.js';
@@ -21,11 +21,11 @@ import * as couponHouse from './contracts/haneulns_coupons/coupon_house.js';
 import * as discounts from './contracts/haneulns_discounts/discounts.js';
 import * as freeClaims from './contracts/haneulns_discounts/free_claims.js';
 
-export class SuinsTransaction {
-	haneulnsClient: SuinsClient;
+export class HaneulnsTransaction {
+	haneulnsClient: HaneulnsClient;
 	transaction: Transaction;
 
-	constructor(client: SuinsClient, transaction: Transaction) {
+	constructor(client: HaneulnsClient, transaction: Transaction) {
 		this.haneulnsClient = client;
 		this.transaction = transaction;
 	}
@@ -349,7 +349,7 @@ export class SuinsTransaction {
 
 	/**
 	 * Builds the PTB to create a leaf subdomain.
-	 * Parent can be a `SuinsRegistration` or a `SubDomainRegistration` object.
+	 * Parent can be a `HaneulnsRegistration` or a `SubDomainRegistration` object.
 	 * Can be passed in as an ID or a TransactionArgument.
 	 */
 	createLeafSubName({

package/src/index.ts

@@ -1,8 +1,8 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
-export { haneulns, SuinsClient, type SuinsExtensionOptions } from './haneulns-client.js';
-export { SuinsTransaction } from './haneulns-transaction.js';
-export type { SuinsClientConfig, PackageInfo } from './types.js';
+export { haneulns, HaneulnsClient, type HaneulnsExtensionOptions } from './haneulns-client.js';
+export { HaneulnsTransaction } from './haneulns-transaction.js';
+export type { HaneulnsClientConfig, PackageInfo } from './types.js';
 export { ALLOWED_METADATA, mainPackage } from './constants.js';
 export {
 	isSubName,

package/src/types.ts

@@ -98,12 +98,12 @@ export type ReceiptParams = {
 	priceInfoObjectId?: string | null;
 };
 
-export type SuinsClientConfig = {
+export type HaneulnsClientConfig = {
 	client: ClientWithCoreApi;
 	network?: HaneulClientTypes.Network;
 	packageInfo?: PackageInfo;
 };
 
-export type SuinsPriceList = Map<[number, number], number>;
+export type HaneulnsPriceList = Map<[number, number], number>;
 
 export type CoinTypeDiscount = Map<string, number>;