@haneullabs/haneulns 0.1.0 → 1.0.2

package/src/contracts/haneulns_coupons/rules.ts

@@ -0,0 +1,342 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import { type Transaction } from '@haneullabs/haneul/transactions';
+import * as range from './range.js';
+const $moduleName = '@haneulns/coupons::rules';
+export const CouponRules = new MoveStruct({
+	name: `${$moduleName}::CouponRules`,
+	fields: {
+		length: bcs.option(range.Range),
+		available_claims: bcs.option(bcs.u64()),
+		user: bcs.option(bcs.Address),
+		expiration: bcs.option(bcs.u64()),
+		years: bcs.option(range.Range),
+	},
+});
+export interface NewCouponRulesArguments {
+	length: RawTransactionArgument<string | null>;
+	availableClaims: RawTransactionArgument<number | bigint | null>;
+	user: RawTransactionArgument<string | null>;
+	expiration: RawTransactionArgument<number | bigint | null>;
+	years: RawTransactionArgument<string | null>;
+}
+export interface NewCouponRulesOptions {
+	package?: string;
+	arguments:
+		| NewCouponRulesArguments
+		| [
+				length: RawTransactionArgument<string | null>,
+				availableClaims: RawTransactionArgument<number | bigint | null>,
+				user: RawTransactionArgument<string | null>,
+				expiration: RawTransactionArgument<number | bigint | null>,
+				years: RawTransactionArgument<string | null>,
+		  ];
+}
+/**
+ * This is used in a PTB when creating a coupon. Creates a CouponRules object to be
+ * used to create a coupon. All rules are optional, and can be chained (`AND`)
+ * format.
+ *
+ * 1.  Length: The name has to be in range [from, to]
+ * 2.  Max available claims
+ * 3.  Only for a specific address
+ * 4.  Might have an expiration date.
+ * 5.  Might be valid only for registrations in a range [from, to]
+ */
+export function newCouponRules(options: NewCouponRulesOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [
+		'0x1::option::Option<null>',
+		'0x1::option::Option<u64>',
+		'0x1::option::Option<address>',
+		'0x1::option::Option<u64>',
+		'0x1::option::Option<null>',
+	] satisfies (string | null)[];
+	const parameterNames = ['length', 'availableClaims', 'user', 'expiration', 'years'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'new_coupon_rules',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface NewEmptyRulesOptions {
+	package?: string;
+	arguments?: [];
+}
+export function newEmptyRules(options: NewEmptyRulesOptions = {}) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'new_empty_rules',
+		});
+}
+export interface DecreaseAvailableClaimsArguments {
+	rules: RawTransactionArgument<string>;
+}
+export interface DecreaseAvailableClaimsOptions {
+	package?: string;
+	arguments: DecreaseAvailableClaimsArguments | [rules: RawTransactionArgument<string>];
+}
+/**
+ * If the rules count `available_claims`, we decrease it. Aborts if there are no
+ * more available claims on that coupon. We shouldn't get here ever, as we're
+ * checking this on the coupon creation, but keeping it as a sanity check (e.g.
+ * created a coupon with 0 available claims).
+ */
+export function decreaseAvailableClaims(options: DecreaseAvailableClaimsOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['rules'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'decrease_available_claims',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface HasAvailableClaimsArguments {
+	rules: RawTransactionArgument<string>;
+}
+export interface HasAvailableClaimsOptions {
+	package?: string;
+	arguments: HasAvailableClaimsArguments | [rules: RawTransactionArgument<string>];
+}
+export function hasAvailableClaims(options: HasAvailableClaimsOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['rules'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'has_available_claims',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AssertCouponValidForDomainYearsArguments {
+	rules: RawTransactionArgument<string>;
+	target: RawTransactionArgument<number>;
+}
+export interface AssertCouponValidForDomainYearsOptions {
+	package?: string;
+	arguments:
+		| AssertCouponValidForDomainYearsArguments
+		| [rules: RawTransactionArgument<string>, target: RawTransactionArgument<number>];
+}
+export function assertCouponValidForDomainYears(options: AssertCouponValidForDomainYearsOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null, 'u8'] satisfies (string | null)[];
+	const parameterNames = ['rules', 'target'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'assert_coupon_valid_for_domain_years',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface IsCouponValidForDomainYearsArguments {
+	rules: RawTransactionArgument<string>;
+	target: RawTransactionArgument<number>;
+}
+export interface IsCouponValidForDomainYearsOptions {
+	package?: string;
+	arguments:
+		| IsCouponValidForDomainYearsArguments
+		| [rules: RawTransactionArgument<string>, target: RawTransactionArgument<number>];
+}
+export function isCouponValidForDomainYears(options: IsCouponValidForDomainYearsOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null, 'u8'] satisfies (string | null)[];
+	const parameterNames = ['rules', 'target'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'is_coupon_valid_for_domain_years',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AssertIsValidDiscountTypeArguments {
+	type: RawTransactionArgument<number>;
+}
+export interface AssertIsValidDiscountTypeOptions {
+	package?: string;
+	arguments: AssertIsValidDiscountTypeArguments | [type: RawTransactionArgument<number>];
+}
+export function assertIsValidDiscountType(options: AssertIsValidDiscountTypeOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = ['u8'] satisfies (string | null)[];
+	const parameterNames = ['type'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'assert_is_valid_discount_type',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AssertIsValidAmountArguments {
+	_: RawTransactionArgument<number>;
+	amount: RawTransactionArgument<number | bigint>;
+}
+export interface AssertIsValidAmountOptions {
+	package?: string;
+	arguments:
+		| AssertIsValidAmountArguments
+		| [_: RawTransactionArgument<number>, amount: RawTransactionArgument<number | bigint>];
+}
+export function assertIsValidAmount(options: AssertIsValidAmountOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = ['u8', 'u64'] satisfies (string | null)[];
+	const parameterNames = ['_', 'amount'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'assert_is_valid_amount',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AssertCouponValidForDomainSizeArguments {
+	rules: RawTransactionArgument<string>;
+	length: RawTransactionArgument<number>;
+}
+export interface AssertCouponValidForDomainSizeOptions {
+	package?: string;
+	arguments:
+		| AssertCouponValidForDomainSizeArguments
+		| [rules: RawTransactionArgument<string>, length: RawTransactionArgument<number>];
+}
+export function assertCouponValidForDomainSize(options: AssertCouponValidForDomainSizeOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null, 'u8'] satisfies (string | null)[];
+	const parameterNames = ['rules', 'length'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'assert_coupon_valid_for_domain_size',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface IsCouponValidForDomainSizeArguments {
+	rules: RawTransactionArgument<string>;
+	length: RawTransactionArgument<number>;
+}
+export interface IsCouponValidForDomainSizeOptions {
+	package?: string;
+	arguments:
+		| IsCouponValidForDomainSizeArguments
+		| [rules: RawTransactionArgument<string>, length: RawTransactionArgument<number>];
+}
+/** We check the length of the name based on the domain length rule */
+export function isCouponValidForDomainSize(options: IsCouponValidForDomainSizeOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null, 'u8'] satisfies (string | null)[];
+	const parameterNames = ['rules', 'length'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'is_coupon_valid_for_domain_size',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AssertCouponValidForAddressArguments {
+	rules: RawTransactionArgument<string>;
+	user: RawTransactionArgument<string>;
+}
+export interface AssertCouponValidForAddressOptions {
+	package?: string;
+	arguments:
+		| AssertCouponValidForAddressArguments
+		| [rules: RawTransactionArgument<string>, user: RawTransactionArgument<string>];
+}
+/** Throws `EInvalidUser` error if it has expired. */
+export function assertCouponValidForAddress(options: AssertCouponValidForAddressOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['rules', 'user'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'assert_coupon_valid_for_address',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface IsCouponValidForAddressArguments {
+	rules: RawTransactionArgument<string>;
+	user: RawTransactionArgument<string>;
+}
+export interface IsCouponValidForAddressOptions {
+	package?: string;
+	arguments:
+		| IsCouponValidForAddressArguments
+		| [rules: RawTransactionArgument<string>, user: RawTransactionArgument<string>];
+}
+/** Check that the domain is valid for the specified address */
+export function isCouponValidForAddress(options: IsCouponValidForAddressOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['rules', 'user'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'is_coupon_valid_for_address',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AssertCouponIsNotExpiredArguments {
+	rules: RawTransactionArgument<string>;
+}
+export interface AssertCouponIsNotExpiredOptions {
+	package?: string;
+	arguments: AssertCouponIsNotExpiredArguments | [rules: RawTransactionArgument<string>];
+}
+/**
+ * Simple assertion for the coupon expiration. Throws `ECouponExpired` error if it
+ * has expired.
+ */
+export function assertCouponIsNotExpired(options: AssertCouponIsNotExpiredOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null, '0x2::clock::Clock'] satisfies (string | null)[];
+	const parameterNames = ['rules'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'assert_coupon_is_not_expired',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface IsCouponExpiredArguments {
+	rules: RawTransactionArgument<string>;
+}
+export interface IsCouponExpiredOptions {
+	package?: string;
+	arguments: IsCouponExpiredArguments | [rules: RawTransactionArgument<string>];
+}
+/** Check whether a coupon has expired */
+export function isCouponExpired(options: IsCouponExpiredOptions) {
+	const packageAddress = options.package ?? '@haneulns/coupons';
+	const argumentsTypes = [null, '0x2::clock::Clock'] satisfies (string | null)[];
+	const parameterNames = ['rules'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'rules',
+			function: 'is_coupon_expired',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}

package/src/contracts/haneulns_discounts/deps/haneul/linked_table.ts

@@ -0,0 +1,27 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Similar to `haneul::table` but the values are linked together, allowing for ordered
+ * insertion and removal
+ */
+
+import { type BcsType, bcs } from '@haneullabs/haneul/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::linked_table';
+export function LinkedTable<K extends BcsType<any>>(...typeParameters: [K]) {
+	return new MoveStruct({
+		name: `${$moduleName}::LinkedTable<${typeParameters[0].name as K['name']}, phantom V>`,
+		fields: {
+			/** the ID of this table */
+			id: bcs.Address,
+			/** the number of key-value pairs in the table */
+			size: bcs.u64(),
+			/** the front of the table, i.e. the key of the first entry */
+			head: bcs.option(typeParameters[0]),
+			/** the back of the table, i.e. the key of the last entry */
+			tail: bcs.option(typeParameters[0]),
+		},
+	});
+}

package/src/contracts/haneulns_discounts/deps/haneulns/pricing_config.ts

@@ -0,0 +1,10 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveTuple } from '../../../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = 'haneulns::pricing_config';
+export const Range = new MoveTuple({
+	name: `${$moduleName}::Range`,
+	fields: [bcs.u64(), bcs.u64()],
+});

package/src/contracts/haneulns_discounts/discounts.ts

@@ -0,0 +1,156 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A module that allows purchasing names in a different price by presenting a
+ * reference of type T. Each `T` can have a separate configuration for a discount
+ * percentage. If a `T` doesn't exist, registration will fail.
+ *
+ * Can be called only when promotions are active for a specific type T. Activation
+ * / deactivation happens through PTBs.
+ */
+
+import { MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs, type BcsType } from '@haneullabs/haneul/bcs';
+import { type Transaction } from '@haneullabs/haneul/transactions';
+const $moduleName = '@haneulns/discounts::discounts';
+export const RegularDiscountsApp = new MoveTuple({
+	name: `${$moduleName}::RegularDiscountsApp`,
+	fields: [bcs.bool()],
+});
+export const DiscountKey = new MoveTuple({
+	name: `${$moduleName}::DiscountKey<phantom T>`,
+	fields: [bcs.bool()],
+});
+export interface ApplyPercentageDiscountArguments<T extends BcsType<any>> {
+	self: RawTransactionArgument<string>;
+	intent: RawTransactionArgument<string>;
+	haneulns: RawTransactionArgument<string>;
+	_: RawTransactionArgument<T>;
+}
+export interface ApplyPercentageDiscountOptions<T extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| ApplyPercentageDiscountArguments<T>
+		| [
+				self: RawTransactionArgument<string>,
+				intent: RawTransactionArgument<string>,
+				haneulns: RawTransactionArgument<string>,
+				_: RawTransactionArgument<T>,
+		  ];
+	typeArguments: [string];
+}
+/** A function to register a name with a discount using type `T`. */
+export function applyPercentageDiscount<T extends BcsType<any>>(
+	options: ApplyPercentageDiscountOptions<T>,
+) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null, null, `${options.typeArguments[0]}`] satisfies (
+		| string
+		| null
+	)[];
+	const parameterNames = ['self', 'intent', 'haneulns', '_'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'discounts',
+			function: 'apply_percentage_discount',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ApplyDayOneDiscountArguments {
+	self: RawTransactionArgument<string>;
+	intent: RawTransactionArgument<string>;
+	haneulns: RawTransactionArgument<string>;
+	dayOne: RawTransactionArgument<string>;
+}
+export interface ApplyDayOneDiscountOptions {
+	package?: string;
+	arguments:
+		| ApplyDayOneDiscountArguments
+		| [
+				self: RawTransactionArgument<string>,
+				intent: RawTransactionArgument<string>,
+				haneulns: RawTransactionArgument<string>,
+				dayOne: RawTransactionArgument<string>,
+		  ];
+}
+/**
+ * A special function for DayOne registration. We separate it from the normal
+ * registration flow because we only want it to be usable for activated DayOnes.
+ */
+export function applyDayOneDiscount(options: ApplyDayOneDiscountOptions) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null, null, null] satisfies (string | null)[];
+	const parameterNames = ['self', 'intent', 'haneulns', 'dayOne'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'discounts',
+			function: 'apply_day_one_discount',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AuthorizeTypeArguments {
+	self: RawTransactionArgument<string>;
+	_: RawTransactionArgument<string>;
+	pricingConfig: RawTransactionArgument<string>;
+}
+export interface AuthorizeTypeOptions {
+	package?: string;
+	arguments:
+		| AuthorizeTypeArguments
+		| [
+				self: RawTransactionArgument<string>,
+				_: RawTransactionArgument<string>,
+				pricingConfig: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * An admin action to authorize a type T for special pricing.
+ *
+ * When authorizing, we reuse the core `PricingConfig` struct, and only accept it
+ * if all the values are in the [0, 100] range. make sure that all the percentages
+ * are in the [0, 99] range. We can use `free_claims` to giveaway free names.
+ */
+export function authorizeType(options: AuthorizeTypeOptions) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null, null] satisfies (string | null)[];
+	const parameterNames = ['self', '_', 'pricingConfig'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'discounts',
+			function: 'authorize_type',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface DeauthorizeTypeArguments {
+	_: RawTransactionArgument<string>;
+	self: RawTransactionArgument<string>;
+}
+export interface DeauthorizeTypeOptions {
+	package?: string;
+	arguments:
+		| DeauthorizeTypeArguments
+		| [_: RawTransactionArgument<string>, self: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** An admin action to deauthorize type T from getting discounts. */
+export function deauthorizeType(options: DeauthorizeTypeOptions) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['_', 'self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'discounts',
+			function: 'deauthorize_type',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/haneulns_discounts/free_claims.ts

@@ -0,0 +1,161 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A module that allows claiming names of a set length for free by presenting an
+ * object T. Each `T` can have a separate configuration for a discount percentage.
+ * If a `T` doesn't exist, registration will fail.
+ *
+ * Can be called only when promotions are active for a specific type T. Activation
+ * / deactivation happens through PTBs.
+ */
+
+import {
+	MoveTuple,
+	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 pricing_config from './deps/haneulns/pricing_config.js';
+import * as linked_table from './deps/haneul/linked_table.js';
+const $moduleName = '@haneulns/discounts::free_claims';
+export const FreeClaimsApp = new MoveTuple({
+	name: `${$moduleName}::FreeClaimsApp`,
+	fields: [bcs.bool()],
+});
+export const FreeClaimsKey = new MoveTuple({
+	name: `${$moduleName}::FreeClaimsKey<phantom T>`,
+	fields: [bcs.bool()],
+});
+export const FreeClaimsConfig = new MoveStruct({
+	name: `${$moduleName}::FreeClaimsConfig`,
+	fields: {
+		domain_length_range: pricing_config.Range,
+		used_objects: linked_table.LinkedTable(bcs.Address),
+	},
+});
+export interface FreeClaimArguments<T extends BcsType<any>> {
+	self: RawTransactionArgument<string>;
+	haneulns: RawTransactionArgument<string>;
+	intent: RawTransactionArgument<string>;
+	object: RawTransactionArgument<T>;
+}
+export interface FreeClaimOptions<T extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| FreeClaimArguments<T>
+		| [
+				self: RawTransactionArgument<string>,
+				haneulns: RawTransactionArgument<string>,
+				intent: RawTransactionArgument<string>,
+				object: RawTransactionArgument<T>,
+		  ];
+	typeArguments: [string];
+}
+/** A function to register a name with a discount using type `T`. */
+export function freeClaim<T extends BcsType<any>>(options: FreeClaimOptions<T>) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null, null, `${options.typeArguments[0]}`] satisfies (
+		| string
+		| null
+	)[];
+	const parameterNames = ['self', 'haneulns', 'intent', 'object'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'free_claims',
+			function: 'free_claim',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface FreeClaimWithDayOneArguments {
+	self: RawTransactionArgument<string>;
+	haneulns: RawTransactionArgument<string>;
+	intent: RawTransactionArgument<string>;
+	dayOne: RawTransactionArgument<string>;
+}
+export interface FreeClaimWithDayOneOptions {
+	package?: string;
+	arguments:
+		| FreeClaimWithDayOneArguments
+		| [
+				self: RawTransactionArgument<string>,
+				haneulns: RawTransactionArgument<string>,
+				intent: RawTransactionArgument<string>,
+				dayOne: RawTransactionArgument<string>,
+		  ];
+}
+export function freeClaimWithDayOne(options: FreeClaimWithDayOneOptions) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null, null, null] satisfies (string | null)[];
+	const parameterNames = ['self', 'haneulns', 'intent', 'dayOne'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'free_claims',
+			function: 'free_claim_with_day_one',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AuthorizeTypeArguments {
+	self: RawTransactionArgument<string>;
+	_: RawTransactionArgument<string>;
+	domainLengthRange: RawTransactionArgument<string>;
+}
+export interface AuthorizeTypeOptions {
+	package?: string;
+	arguments:
+		| AuthorizeTypeArguments
+		| [
+				self: RawTransactionArgument<string>,
+				_: RawTransactionArgument<string>,
+				domainLengthRange: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * An admin action to authorize a type T for free claiming of names by presenting
+ * an object of type `T`.
+ */
+export function authorizeType(options: AuthorizeTypeOptions) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null, null] satisfies (string | null)[];
+	const parameterNames = ['self', '_', 'domainLengthRange'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'free_claims',
+			function: 'authorize_type',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface DeauthorizeTypeArguments {
+	self: RawTransactionArgument<string>;
+	_: RawTransactionArgument<string>;
+}
+export interface DeauthorizeTypeOptions {
+	package?: string;
+	arguments:
+		| DeauthorizeTypeArguments
+		| [self: RawTransactionArgument<string>, _: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Force-deauthorize type T from free claims. Drops the linked_table. */
+export function deauthorizeType(options: DeauthorizeTypeOptions) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['self', '_'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'free_claims',
+			function: 'deauthorize_type',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}