@haneullabs/haneulns 0.1.0 → 1.0.2

package/src/contracts/haneulns_discounts/house.ts

@@ -0,0 +1,47 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A base module that holds a shared object for the configuration of the package
+ * and exports some package utilities for the 2 systems to use.
+ */
+
+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/discounts::house';
+export const DiscountHouse = new MoveStruct({
+	name: `${$moduleName}::DiscountHouse`,
+	fields: {
+		id: bcs.Address,
+		version: bcs.u8(),
+	},
+});
+export interface SetVersionArguments {
+	self: RawTransactionArgument<string>;
+	_: RawTransactionArgument<string>;
+	version: RawTransactionArgument<number>;
+}
+export interface SetVersionOptions {
+	package?: string;
+	arguments:
+		| SetVersionArguments
+		| [
+				self: RawTransactionArgument<string>,
+				_: RawTransactionArgument<string>,
+				version: RawTransactionArgument<number>,
+		  ];
+}
+export function setVersion(options: SetVersionOptions) {
+	const packageAddress = options.package ?? '@haneulns/discounts';
+	const argumentsTypes = [null, null, 'u8'] satisfies (string | null)[];
+	const parameterNames = ['self', '_', 'version'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'house',
+			function: 'set_version',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}

package/src/contracts/haneulns_payments/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_payments/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_payments/payments.ts

@@ -0,0 +1,257 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import {
+	MoveTuple,
+	MoveStruct,
+	normalizeMoveArguments,
+	type RawTransactionArgument,
+} from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import { type Transaction } from '@haneullabs/haneul/transactions';
+import * as type_name from './deps/std/type_name.js';
+import * as vec_map from './deps/haneul/vec_map.js';
+const $moduleName = '@haneulns/payments::payments';
+export const PaymentsApp = new MoveTuple({
+	name: `${$moduleName}::PaymentsApp`,
+	fields: [bcs.bool()],
+});
+export const CoinTypeData = new MoveStruct({
+	name: `${$moduleName}::CoinTypeData`,
+	fields: {
+		/** The coin's decimals. */
+		decimals: bcs.u8(),
+		discount_percentage: bcs.u8(),
+		price_feed_id: bcs.vector(bcs.u8()),
+		type_name: type_name.TypeName,
+	},
+});
+export const PaymentsConfig = new MoveStruct({
+	name: `${$moduleName}::PaymentsConfig`,
+	fields: {
+		currencies: vec_map.VecMap(type_name.TypeName, CoinTypeData),
+		base_currency: type_name.TypeName,
+		max_age: bcs.u64(),
+		/** The percentage of the payment that gets burned, in basis points. */
+		burn_bps: bcs.u64(),
+	},
+});
+export interface HandleBasePaymentArguments {
+	haneulns: RawTransactionArgument<string>;
+	bbbVault: RawTransactionArgument<string>;
+	intent: RawTransactionArgument<string>;
+	payment: RawTransactionArgument<string>;
+}
+export interface HandleBasePaymentOptions {
+	package?: string;
+	arguments:
+		| HandleBasePaymentArguments
+		| [
+				haneulns: RawTransactionArgument<string>,
+				bbbVault: RawTransactionArgument<string>,
+				intent: RawTransactionArgument<string>,
+				payment: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * This has to be called with our base payment currency. The payment has to be
+ * equal to the base price of the domain. We do not need to check the price feed
+ * for the base currency.
+ */
+export function handleBasePayment(options: HandleBasePaymentOptions) {
+	const packageAddress = options.package ?? '@haneulns/payments';
+	const argumentsTypes = [null, null, null, null] satisfies (string | null)[];
+	const parameterNames = ['haneulns', 'bbbVault', 'intent', 'payment'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'payments',
+			function: 'handle_base_payment',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface HandlePaymentArguments {
+	haneulns: RawTransactionArgument<string>;
+	bbbVault: RawTransactionArgument<string>;
+	intent: RawTransactionArgument<string>;
+	payment: RawTransactionArgument<string>;
+	priceInfoObject: RawTransactionArgument<string>;
+	userPriceGuard: RawTransactionArgument<number | bigint>;
+}
+export interface HandlePaymentOptions {
+	package?: string;
+	arguments:
+		| HandlePaymentArguments
+		| [
+				haneulns: RawTransactionArgument<string>,
+				bbbVault: RawTransactionArgument<string>,
+				intent: RawTransactionArgument<string>,
+				payment: RawTransactionArgument<string>,
+				priceInfoObject: RawTransactionArgument<string>,
+				userPriceGuard: RawTransactionArgument<number | bigint>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * Handles a payment done for a non-base currency payment. E.g. HANEUL, NS.
+ *
+ * The payment amount is derived from the base currency price and the Pyth price
+ * feed.
+ *
+ * The `user_price_guard` is a value that the user expects to pay. If the payment
+ * amount is higher than this value, the payment will be rejected. This is to
+ * protect the user from paying more than they expected on their FEs. Ideally, this
+ * number should be calculated on the FE based on the price that is being displayed
+ * to the user (with a buffer determined by the FE).
+ */
+export function handlePayment(options: HandlePaymentOptions) {
+	const packageAddress = options.package ?? '@haneulns/payments';
+	const argumentsTypes = [null, null, null, null, '0x2::clock::Clock', null, 'u64'] satisfies (
+		| string
+		| null
+	)[];
+	const parameterNames = [
+		'haneulns',
+		'bbbVault',
+		'intent',
+		'payment',
+		'priceInfoObject',
+		'userPriceGuard',
+	];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'payments',
+			function: 'handle_payment',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface CalculatePriceArguments {
+	haneulns: RawTransactionArgument<string>;
+	baseAmount: RawTransactionArgument<number | bigint>;
+	priceInfoObject: RawTransactionArgument<string>;
+}
+export interface CalculatePriceOptions {
+	package?: string;
+	arguments:
+		| CalculatePriceArguments
+		| [
+				haneulns: RawTransactionArgument<string>,
+				baseAmount: RawTransactionArgument<number | bigint>,
+				priceInfoObject: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * Calculates the amount that has to be paid in the target currency.
+ *
+ * Can be used to split the payment amount in a single PTB.
+ *
+ * 1.  const intent = function_to_get_intent();
+ * 2.  const price = calculate_price<HANEUL>(haneulns, intent, ...);
+ * 3.  const coin = txb.splitCoins(baseCoin, [price])
+ * 4.  handle_payment<HANEUL>(haneulns, intent, coin, ...);
+ */
+export function calculatePrice(options: CalculatePriceOptions) {
+	const packageAddress = options.package ?? '@haneulns/payments';
+	const argumentsTypes = [null, 'u64', '0x2::clock::Clock', null] satisfies (string | null)[];
+	const parameterNames = ['haneulns', 'baseAmount', 'priceInfoObject'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'payments',
+			function: 'calculate_price',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface CalculatePriceAfterDiscountArguments {
+	haneulns: RawTransactionArgument<string>;
+	intent: RawTransactionArgument<string>;
+}
+export interface CalculatePriceAfterDiscountOptions {
+	package?: string;
+	arguments:
+		| CalculatePriceAfterDiscountArguments
+		| [haneulns: RawTransactionArgument<string>, intent: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function calculatePriceAfterDiscount(options: CalculatePriceAfterDiscountOptions) {
+	const packageAddress = options.package ?? '@haneulns/payments';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['haneulns', 'intent'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'payments',
+			function: 'calculate_price_after_discount',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface NewCoinTypeDataArguments {
+	coinMetadata: RawTransactionArgument<string>;
+	discountPercentage: RawTransactionArgument<number>;
+	priceFeedId: RawTransactionArgument<number[]>;
+}
+export interface NewCoinTypeDataOptions {
+	package?: string;
+	arguments:
+		| NewCoinTypeDataArguments
+		| [
+				coinMetadata: RawTransactionArgument<string>,
+				discountPercentage: RawTransactionArgument<number>,
+				priceFeedId: RawTransactionArgument<number[]>,
+		  ];
+	typeArguments: [string];
+}
+/** Creates a new CoinTypeData struct. Leave price_feed_id empty for base currency. */
+export function newCoinTypeData(options: NewCoinTypeDataOptions) {
+	const packageAddress = options.package ?? '@haneulns/payments';
+	const argumentsTypes = [null, 'u8', 'vector<u8>'] satisfies (string | null)[];
+	const parameterNames = ['coinMetadata', 'discountPercentage', 'priceFeedId'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'payments',
+			function: 'new_coin_type_data',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface NewPaymentsConfigArguments {
+	setups: RawTransactionArgument<string[]>;
+	baseCurrency: RawTransactionArgument<string>;
+	maxAge: RawTransactionArgument<number | bigint>;
+	burnBps: RawTransactionArgument<number | bigint>;
+}
+export interface NewPaymentsConfigOptions {
+	package?: string;
+	arguments:
+		| NewPaymentsConfigArguments
+		| [
+				setups: RawTransactionArgument<string[]>,
+				baseCurrency: RawTransactionArgument<string>,
+				maxAge: RawTransactionArgument<number | bigint>,
+				burnBps: RawTransactionArgument<number | bigint>,
+		  ];
+}
+/**
+ * Creates a new PaymentsConfig struct. Can be attached by the Admin to HaneulNS to
+ * allow the payments module to work.
+ */
+export function newPaymentsConfig(options: NewPaymentsConfigOptions) {
+	const packageAddress = options.package ?? '@haneulns/payments';
+	const argumentsTypes = ['vector<null>', null, 'u64', 'u64'] satisfies (string | null)[];
+	const parameterNames = ['setups', 'baseCurrency', 'maxAge', 'burnBps'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'payments',
+			function: 'new_payments_config',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}