@haneullabs/haneulns 0.1.0 → 1.0.3

package/src/contracts/haneulns/haneulns.ts

@@ -0,0 +1,456 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * The main module of the HaneulNS application, defines the `HaneulNS` object and the
+ * authorization mechanism for interacting with the main data storage.
+ *
+ * Authorization mechanic: The Admin can authorize applications to access protected
+ * features of the HaneulNS, they're named with a prefix `app_*`. Once authorized,
+ * application can get mutable access to the `Registry` and add to the application
+ * `Balance`.
+ *
+ * At any moment any of the applications can be deathorized by the Admin making it
+ * impossible for the deauthorized module to access the registry.
+ *
+ * ---
+ *
+ * Package Upgrades in mind:
+ *
+ * - None of the public functions of the HaneulNS feature any specific types - instead
+ *   we use generics to define the actual types in arbitrary modules.
+ * - The `Registry` itself (the main feature of the application) is stored as a
+ *   dynamic field so that we can change the type and the module that serves the
+ *   registry without breaking the HaneulNS compatibility.
+ * - Any of the old modules can be deauthorized hence disabling its access to the
+ *   registry and the balance.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs, type BcsType } from '@haneullabs/haneul/bcs';
+import { type Transaction } from '@haneullabs/haneul/transactions';
+import * as balance from './deps/haneul/balance.js';
+const $moduleName = '@haneulns/core::haneulns';
+export const AdminCap = new MoveStruct({
+	name: `${$moduleName}::AdminCap`,
+	fields: {
+		id: bcs.Address,
+	},
+});
+export const HaneulNS = new MoveStruct({
+	name: `${$moduleName}::HaneulNS`,
+	fields: {
+		id: bcs.Address,
+		/**
+		 * The total balance of the HaneulNS. Can be added to by authorized apps. Can be
+		 * withdrawn only by the application Admin.
+		 */
+		balance: balance.Balance,
+	},
+});
+export const HANEULNS = new MoveStruct({
+	name: `${$moduleName}::HANEULNS`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const ConfigKey = new MoveStruct({
+	name: `${$moduleName}::ConfigKey<phantom Config>`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const RegistryKey = new MoveStruct({
+	name: `${$moduleName}::RegistryKey<phantom Config>`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const BalanceKey = new MoveStruct({
+	name: `${$moduleName}::BalanceKey<phantom T>`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const AppKey = new MoveStruct({
+	name: `${$moduleName}::AppKey<phantom App>`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export interface WithdrawArguments {
+	_: RawTransactionArgument<string>;
+	self: RawTransactionArgument<string>;
+}
+export interface WithdrawOptions {
+	package?: string;
+	arguments:
+		| WithdrawArguments
+		| [_: RawTransactionArgument<string>, self: RawTransactionArgument<string>];
+}
+/**
+ * Withdraw from the HaneulNS balance directly and access the Coins within the same
+ * transaction. This is useful for the admin to withdraw funds from the HaneulNS and
+ * then send them somewhere specific or keep at the address.
+ */
+export function withdraw(options: WithdrawOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['_', 'self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'withdraw',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface WithdrawCustomArguments {
+	self: RawTransactionArgument<string>;
+	_: RawTransactionArgument<string>;
+}
+export interface WithdrawCustomOptions {
+	package?: string;
+	arguments:
+		| WithdrawCustomArguments
+		| [self: RawTransactionArgument<string>, _: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Withdraw from the HaneulNS balance of a custom coin type. */
+export function withdrawCustom(options: WithdrawCustomOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['self', '_'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'withdraw_custom',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AuthorizeAppArguments {
+	_: RawTransactionArgument<string>;
+	self: RawTransactionArgument<string>;
+}
+export interface AuthorizeAppOptions {
+	package?: string;
+	arguments:
+		| AuthorizeAppArguments
+		| [_: RawTransactionArgument<string>, self: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Authorize an application to access protected features of the HaneulNS. */
+export function authorizeApp(options: AuthorizeAppOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['_', 'self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'authorize_app',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface DeauthorizeAppArguments {
+	_: RawTransactionArgument<string>;
+	self: RawTransactionArgument<string>;
+}
+export interface DeauthorizeAppOptions {
+	package?: string;
+	arguments:
+		| DeauthorizeAppArguments
+		| [_: RawTransactionArgument<string>, self: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Deauthorize an application by removing its authorization key. */
+export function deauthorizeApp(options: DeauthorizeAppOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['_', 'self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'deauthorize_app',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface IsAppAuthorizedArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface IsAppAuthorizedOptions {
+	package?: string;
+	arguments: IsAppAuthorizedArguments | [self: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Check if an application is authorized to access protected features of the HaneulNS. */
+export function isAppAuthorized(options: IsAppAuthorizedOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'is_app_authorized',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AssertAppIsAuthorizedArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface AssertAppIsAuthorizedOptions {
+	package?: string;
+	arguments: AssertAppIsAuthorizedArguments | [self: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/**
+ * Assert that an application is authorized to access protected features of the
+ * HaneulNS. Aborts with `EAppNotAuthorized` if not.
+ */
+export function assertAppIsAuthorized(options: AssertAppIsAuthorizedOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'assert_app_is_authorized',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AppAddBalanceArguments<App extends BcsType<any>> {
+	_: RawTransactionArgument<App>;
+	self: RawTransactionArgument<string>;
+	balance: RawTransactionArgument<string>;
+}
+export interface AppAddBalanceOptions<App extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| AppAddBalanceArguments<App>
+		| [
+				_: RawTransactionArgument<App>,
+				self: RawTransactionArgument<string>,
+				balance: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string];
+}
+/** Adds balance to the HaneulNS. */
+export function appAddBalance<App extends BcsType<any>>(options: AppAddBalanceOptions<App>) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [`${options.typeArguments[0]}`, null, null] satisfies (string | null)[];
+	const parameterNames = ['_', 'self', 'balance'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'app_add_balance',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AppAddCustomBalanceArguments<App extends BcsType<any>> {
+	self: RawTransactionArgument<string>;
+	_: RawTransactionArgument<App>;
+	balance: RawTransactionArgument<string>;
+}
+export interface AppAddCustomBalanceOptions<App extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| AppAddCustomBalanceArguments<App>
+		| [
+				self: RawTransactionArgument<string>,
+				_: RawTransactionArgument<App>,
+				balance: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string, string];
+}
+/** Adds a balance of type `T` to the HaneulNS protocol as an authorized app. */
+export function appAddCustomBalance<App extends BcsType<any>>(
+	options: AppAddCustomBalanceOptions<App>,
+) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, `${options.typeArguments[0]}`, null] satisfies (string | null)[];
+	const parameterNames = ['self', '_', 'balance'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'app_add_custom_balance',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AppRegistryMutArguments<App extends BcsType<any>> {
+	_: RawTransactionArgument<App>;
+	self: RawTransactionArgument<string>;
+}
+export interface AppRegistryMutOptions<App extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| AppRegistryMutArguments<App>
+		| [_: RawTransactionArgument<App>, self: RawTransactionArgument<string>];
+	typeArguments: [string, string];
+}
+/**
+ * Get a mutable access to the `Registry` object. Can only be performed by
+ * authorized applications.
+ */
+export function appRegistryMut<App extends BcsType<any>>(options: AppRegistryMutOptions<App>) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [`${options.typeArguments[0]}`, null] satisfies (string | null)[];
+	const parameterNames = ['_', 'self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'app_registry_mut',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AddConfigArguments<Config extends BcsType<any>> {
+	_: RawTransactionArgument<string>;
+	self: RawTransactionArgument<string>;
+	config: RawTransactionArgument<Config>;
+}
+export interface AddConfigOptions<Config extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| AddConfigArguments<Config>
+		| [
+				_: RawTransactionArgument<string>,
+				self: RawTransactionArgument<string>,
+				config: RawTransactionArgument<Config>,
+		  ];
+	typeArguments: [string];
+}
+/** Attach dynamic configuration object to the application. */
+export function addConfig<Config extends BcsType<any>>(options: AddConfigOptions<Config>) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, null, `${options.typeArguments[0]}`] satisfies (string | null)[];
+	const parameterNames = ['_', 'self', 'config'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'add_config',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface GetConfigArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface GetConfigOptions {
+	package?: string;
+	arguments: GetConfigArguments | [self: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Borrow configuration object. Read-only mode for applications. */
+export function getConfig(options: GetConfigOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'get_config',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface RemoveConfigArguments {
+	_: RawTransactionArgument<string>;
+	self: RawTransactionArgument<string>;
+}
+export interface RemoveConfigOptions {
+	package?: string;
+	arguments:
+		| RemoveConfigArguments
+		| [_: RawTransactionArgument<string>, self: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/**
+ * Get the configuration object for editing. The admin should put it back after
+ * editing (no extra check performed). Can be used to swap configuration since the
+ * `T` has `drop`. Eg nothing is stopping the admin from removing the configuration
+ * object and adding a new one.
+ *
+ * Fully taking the config also allows for edits within a transaction.
+ */
+export function removeConfig(options: RemoveConfigOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['_', 'self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'remove_config',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface RegistryArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface RegistryOptions {
+	package?: string;
+	arguments: RegistryArguments | [self: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Get a read-only access to the `Registry` object. */
+export function registry(options: RegistryOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'registry',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AddRegistryArguments<R extends BcsType<any>> {
+	_: RawTransactionArgument<string>;
+	self: RawTransactionArgument<string>;
+	registry: RawTransactionArgument<R>;
+}
+export interface AddRegistryOptions<R extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| AddRegistryArguments<R>
+		| [
+				_: RawTransactionArgument<string>,
+				self: RawTransactionArgument<string>,
+				registry: RawTransactionArgument<R>,
+		  ];
+	typeArguments: [string];
+}
+/** Add a registry to the HaneulNS. Can only be performed by the admin. */
+export function addRegistry<R extends BcsType<any>>(options: AddRegistryOptions<R>) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, null, `${options.typeArguments[0]}`] satisfies (string | null)[];
+	const parameterNames = ['_', 'self', 'registry'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns',
+			function: 'add_registry',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/haneulns/haneulns_registration.ts

@@ -0,0 +1,200 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Handles creation of the `HaneulnsRegistration`s. Separates the logic of creating a
+ * `HaneulnsRegistration`. New `HaneulnsRegistration`s can be created only by the
+ * `registry` and this module is tightly coupled with it.
+ *
+ * When reviewing the module, make sure that:
+ *
+ * - mutable functions can't be called directly by the owner
+ * - all getters are public and take an immutable reference
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import { type Transaction } from '@haneullabs/haneul/transactions';
+import * as domain_1 from './domain.js';
+const $moduleName = '@haneulns/core::haneulns_registration';
+export const HaneulnsRegistration = new MoveStruct({
+	name: `${$moduleName}::HaneulnsRegistration`,
+	fields: {
+		id: bcs.Address,
+		/** The parsed domain. */
+		domain: domain_1.Domain,
+		/** The domain name that the NFT is for. */
+		domain_name: bcs.string(),
+		/** Timestamp in milliseconds when this NFT expires. */
+		expiration_timestamp_ms: bcs.u64(),
+		/** Short IPFS hash of the image to be displayed for the NFT. */
+		image_url: bcs.string(),
+	},
+});
+export interface HasExpiredArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface HasExpiredOptions {
+	package?: string;
+	arguments: HasExpiredArguments | [self: RawTransactionArgument<string>];
+}
+/**
+ * Check whether the `HaneulnsRegistration` has expired by comparing the expiration
+ * timeout with the current time.
+ */
+export function hasExpired(options: HasExpiredOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, '0x2::clock::Clock'] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns_registration',
+			function: 'has_expired',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface HasExpiredPastGracePeriodArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface HasExpiredPastGracePeriodOptions {
+	package?: string;
+	arguments: HasExpiredPastGracePeriodArguments | [self: RawTransactionArgument<string>];
+}
+/**
+ * Check whether the `HaneulnsRegistration` has expired by comparing the expiration
+ * timeout with the current time. This function also takes into account the grace
+ * period.
+ */
+export function hasExpiredPastGracePeriod(options: HasExpiredPastGracePeriodOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, '0x2::clock::Clock'] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns_registration',
+			function: 'has_expired_past_grace_period',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface DomainArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface DomainOptions {
+	package?: string;
+	arguments: DomainArguments | [self: RawTransactionArgument<string>];
+}
+/** Get the `domain` field of the `HaneulnsRegistration`. */
+export function domain(options: DomainOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns_registration',
+			function: 'domain',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface DomainNameArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface DomainNameOptions {
+	package?: string;
+	arguments: DomainNameArguments | [self: RawTransactionArgument<string>];
+}
+/** Get the `domain_name` field of the `HaneulnsRegistration`. */
+export function domainName(options: DomainNameOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns_registration',
+			function: 'domain_name',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface ExpirationTimestampMsArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface ExpirationTimestampMsOptions {
+	package?: string;
+	arguments: ExpirationTimestampMsArguments | [self: RawTransactionArgument<string>];
+}
+/** Get the `expiration_timestamp_ms` field of the `HaneulnsRegistration`. */
+export function expirationTimestampMs(options: ExpirationTimestampMsOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns_registration',
+			function: 'expiration_timestamp_ms',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface ImageUrlArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface ImageUrlOptions {
+	package?: string;
+	arguments: ImageUrlArguments | [self: RawTransactionArgument<string>];
+}
+/** Get the `image_url` field of the `HaneulnsRegistration`. */
+export function imageUrl(options: ImageUrlOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns_registration',
+			function: 'image_url',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface UidArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface UidOptions {
+	package?: string;
+	arguments: UidArguments | [self: RawTransactionArgument<string>];
+}
+export function uid(options: UidOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns_registration',
+			function: 'uid',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface UidMutArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface UidMutOptions {
+	package?: string;
+	arguments: UidMutArguments | [self: RawTransactionArgument<string>];
+}
+/** Get the mutable `id` field of the `HaneulnsRegistration`. */
+export function uidMut(options: UidMutOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'haneulns_registration',
+			function: 'uid_mut',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}