@haneullabs/haneulns 0.1.0 → 1.0.2

package/src/contracts/haneulns/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/deps/haneul/table.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A table is a map-like collection. But unlike a traditional collection, it's keys
+ * and values are not stored within the `Table` value, but instead are stored using
+ * Haneul's object system. The `Table` struct acts only as a handle into the object
+ * system to retrieve those keys and values. Note that this means that `Table`
+ * values with exactly the same key-value mapping will not be equal, with `==`, at
+ * runtime. For example
+ *
+ * ```
+ * let table1 = table::new<u64, bool>();
+ * let table2 = table::new<u64, bool>();
+ * table::add(&mut table1, 0, false);
+ * table::add(&mut table1, 1, true);
+ * table::add(&mut table2, 0, false);
+ * table::add(&mut table2, 1, true);
+ * // table1 does not equal table2, despite having the same entries
+ * assert!(&table1 != &table2);
+ * ```
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = '0x2::table';
+export const Table = new MoveStruct({
+	name: `${$moduleName}::Table<phantom K, phantom V>`,
+	fields: {
+		/** the ID of this table */
+		id: bcs.Address,
+		/** the number of key-value pairs in the table */
+		size: bcs.u64(),
+	},
+});

package/src/contracts/haneulns/deps/haneul/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@haneullabs/haneul/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {
+	return new MoveStruct({
+		name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,
+		fields: {
+			key: typeParameters[0],
+			value: typeParameters[1],
+		},
+	});
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {
+	return new MoveStruct({
+		name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,
+		fields: {
+			contents: bcs.vector(Entry(typeParameters[0], typeParameters[1])),
+		},
+	});
+}

package/src/contracts/haneulns/deps/haneul/vec_set.ts

@@ -0,0 +1,22 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@haneullabs/haneul/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_set';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export function VecSet<K extends BcsType<any>>(...typeParameters: [K]) {
+	return new MoveStruct({
+		name: `${$moduleName}::VecSet<${typeParameters[0].name as K['name']}>`,
+		fields: {
+			contents: bcs.vector(typeParameters[0]),
+		},
+	});
+}

package/src/contracts/haneulns/deps/std/type_name.ts

@@ -0,0 +1,24 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Functionality for converting Move types into values. Use with care! */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = 'std::type_name';
+export const TypeName = new MoveStruct({
+	name: `${$moduleName}::TypeName`,
+	fields: {
+		/**
+		 * String representation of the type. All types are represented using their source
+		 * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+		 * Struct types are represented as fully qualified type names; e.g.
+		 * `00000000000000000000000000000001::string::String` or
+		 * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+		 * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+		 * 32 depending on the Move platform)
+		 */
+		name: bcs.string(),
+	},
+});

package/src/contracts/haneulns/domain.ts

@@ -0,0 +1,230 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Defines the `Domain` type and helper functions.
+ *
+ * Domains are structured similar to their web2 counterpart and the rules
+ * determining what a valid domain is can be found here:
+ * https://en.wikipedia.org/wiki/Domain_name#Domain_name_syntax
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import { type Transaction } from '@haneullabs/haneul/transactions';
+const $moduleName = '@haneulns/core::domain';
+export const Domain = new MoveStruct({
+	name: `${$moduleName}::Domain`,
+	fields: {
+		/**
+		 * Vector of labels that make up a domain.
+		 *
+		 * Labels are stored in reverse order such that the TLD is always in position `0`.
+		 * e.g. domain "pay.name.haneul" will be stored in the vector as ["haneul", "name",
+		 * "pay"].
+		 */
+		labels: bcs.vector(bcs.string()),
+	},
+});
+export interface NewArguments {
+	domain: RawTransactionArgument<string>;
+}
+export interface NewOptions {
+	package?: string;
+	arguments: NewArguments | [domain: RawTransactionArgument<string>];
+}
+export function _new(options: NewOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = ['0x1::string::String'] satisfies (string | null)[];
+	const parameterNames = ['domain'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'new',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface ToStringArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface ToStringOptions {
+	package?: string;
+	arguments: ToStringArguments | [self: RawTransactionArgument<string>];
+}
+/** Converts a domain into a fully-qualified string representation. */
+export function toString(options: ToStringOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'to_string',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface LabelArguments {
+	self: RawTransactionArgument<string>;
+	level: RawTransactionArgument<number | bigint>;
+}
+export interface LabelOptions {
+	package?: string;
+	arguments:
+		| LabelArguments
+		| [self: RawTransactionArgument<string>, level: RawTransactionArgument<number | bigint>];
+}
+/**
+ * Returns the `label` in a domain specified by `level`.
+ *
+ * Given the domain "pay.name.haneul" the individual labels have the following levels:
+ *
+ * - "pay" - `2`
+ * - "name" - `1`
+ * - "haneul" - `0`
+ *
+ * This means that the TLD will always be at level `0`.
+ */
+export function label(options: LabelOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['self', 'level'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'label',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface TldArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface TldOptions {
+	package?: string;
+	arguments: TldArguments | [self: RawTransactionArgument<string>];
+}
+/**
+ * Returns the TLD (Top-Level Domain) of a `Domain`.
+ *
+ * "name.haneul" -> "haneul"
+ */
+export function tld(options: TldOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'tld',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface SldArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface SldOptions {
+	package?: string;
+	arguments: SldArguments | [self: RawTransactionArgument<string>];
+}
+/**
+ * Returns the SLD (Second-Level Domain) of a `Domain`.
+ *
+ * "name.haneul" -> "haneul"
+ */
+export function sld(options: SldOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'sld',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface NumberOfLevelsArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface NumberOfLevelsOptions {
+	package?: string;
+	arguments: NumberOfLevelsArguments | [self: RawTransactionArgument<string>];
+}
+export function numberOfLevels(options: NumberOfLevelsOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'number_of_levels',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface IsSubdomainArguments {
+	domain: RawTransactionArgument<string>;
+}
+export interface IsSubdomainOptions {
+	package?: string;
+	arguments: IsSubdomainArguments | [domain: RawTransactionArgument<string>];
+}
+export function isSubdomain(options: IsSubdomainOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['domain'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'is_subdomain',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface ParentArguments {
+	domain: RawTransactionArgument<string>;
+}
+export interface ParentOptions {
+	package?: string;
+	arguments: ParentArguments | [domain: RawTransactionArgument<string>];
+}
+/** Derive the parent of a subdomain. e.g. `subdomain.example.haneul` -> `example.haneul` */
+export function parent(options: ParentOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['domain'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'parent',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface IsParentOfArguments {
+	parent: RawTransactionArgument<string>;
+	child: RawTransactionArgument<string>;
+}
+export interface IsParentOfOptions {
+	package?: string;
+	arguments:
+		| IsParentOfArguments
+		| [parent: RawTransactionArgument<string>, child: RawTransactionArgument<string>];
+}
+/** Checks if `parent` domain is a valid parent for `child`. */
+export function isParentOf(options: IsParentOfOptions) {
+	const packageAddress = options.package ?? '@haneulns/core';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['parent', 'child'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'domain',
+			function: 'is_parent_of',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}