@haneullabs/kiosk 0.1.0 → 1.1.2

package/src/contracts/kiosk/royalty_rule.ts

@@ -0,0 +1,144 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Description: This module defines a Rule which requires a payment on a purchase.
+ * The payment amount can be either a fixed amount (min_amount) or a percentage of
+ * the purchase price (amount_bp). Or both: the higher of the two is used.
+ *
+ * Configuration:
+ *
+ * - amount_bp - the percentage of the purchase price to be paid as a fee,
+ *   denominated in basis points (100_00 = 100%, 1 = 0.01%).
+ * - min_amount - the minimum amount to be paid as a fee if the relative amount is
+ *   lower than this setting.
+ *
+ * Use cases:
+ *
+ * - Percentage-based Royalty fee for the creator of the NFT.
+ * - Fixed commission fee on a trade.
+ * - A mix of both: the higher of the two is used.
+ *
+ * Notes:
+ *
+ * - To use it as a fixed commission set the `amount_bp` to 0 and use the
+ *   `min_amount` to set the fixed amount.
+ * - To use it as a percentage-based fee set the `min_amount` to 0 and use the
+ *   `amount_bp` to set the percentage.
+ * - To use it as a mix of both set the `min_amount` to the min amount acceptable
+ *   and the `amount_bp` to the percentage of the purchase price. The higher of the
+ *   two will be used.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import { type Transaction } from '@haneullabs/haneul/transactions';
+const $moduleName = '@local-pkg/kiosk::royalty_rule';
+export const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const Config = new MoveStruct({
+	name: `${$moduleName}::Config`,
+	fields: {
+		amount_bp: bcs.u16(),
+		min_amount: bcs.u64(),
+	},
+});
+export interface AddArguments {
+	policy: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+	amountBp: RawTransactionArgument<number>;
+	minAmount: RawTransactionArgument<number | bigint>;
+}
+export interface AddOptions {
+	package?: string;
+	arguments:
+		| AddArguments
+		| [
+				policy: RawTransactionArgument<string>,
+				cap: RawTransactionArgument<string>,
+				amountBp: RawTransactionArgument<number>,
+				minAmount: RawTransactionArgument<number | bigint>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * Creator action: Add the Royalty Rule for the `T`. Pass in the `TransferPolicy`,
+ * `TransferPolicyCap` and the configuration for the policy: `amount_bp` and
+ * `min_amount`.
+ */
+export function add(options: AddOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null, 'u16', 'u64'] satisfies (string | null)[];
+	const parameterNames = ['policy', 'cap', 'amountBp', 'minAmount'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'royalty_rule',
+			function: 'add',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface PayArguments {
+	policy: RawTransactionArgument<string>;
+	request: RawTransactionArgument<string>;
+	payment: RawTransactionArgument<string>;
+}
+export interface PayOptions {
+	package?: string;
+	arguments:
+		| PayArguments
+		| [
+				policy: RawTransactionArgument<string>,
+				request: RawTransactionArgument<string>,
+				payment: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string];
+}
+/** Buyer action: Pay the royalty fee for the transfer. */
+export function pay(options: PayOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null, null] satisfies (string | null)[];
+	const parameterNames = ['policy', 'request', 'payment'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'royalty_rule',
+			function: 'pay',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface FeeAmountArguments {
+	policy: RawTransactionArgument<string>;
+	paid: RawTransactionArgument<number | bigint>;
+}
+export interface FeeAmountOptions {
+	package?: string;
+	arguments:
+		| FeeAmountArguments
+		| [policy: RawTransactionArgument<string>, paid: RawTransactionArgument<number | bigint>];
+	typeArguments: [string];
+}
+/**
+ * Helper function to calculate the amount to be paid for the transfer. Can be used
+ * dry-runned to estimate the fee amount based on the Kiosk listing price.
+ */
+export function feeAmount(options: FeeAmountOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['policy', 'paid'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'royalty_rule',
+			function: 'fee_amount',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/kiosk/witness_rule.ts

@@ -0,0 +1,92 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Description: This module implements a Rule that requires a "Proof" witness to be
+ * presented on every transfer. The "Proof" witness is a type chosen by the owner
+ * of the policy.
+ *
+ * Configuration:
+ *
+ * - The type to require for every transfer.
+ *
+ * Use Cases:
+ *
+ * - Can be used to link custom logic to the TransferPolicy via the Witness.
+ * - Only allow trading on a certain marketplace.
+ * - Require a confirmation in a third party module
+ * - Implement a custom requirement on the creator side an link the logic.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs, type BcsType } from '@haneullabs/haneul/bcs';
+import { type Transaction } from '@haneullabs/haneul/transactions';
+const $moduleName = '@local-pkg/kiosk::witness_rule';
+export const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule<phantom Proof>`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export interface AddArguments {
+	policy: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+}
+export interface AddOptions {
+	package?: string;
+	arguments:
+		| AddArguments
+		| [policy: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];
+	typeArguments: [string, string];
+}
+/**
+ * Creator action: adds the Rule. Requires a "Proof" witness confirmation on every
+ * transfer.
+ */
+export function add(options: AddOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['policy', 'cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'witness_rule',
+			function: 'add',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ProveArguments<Proof extends BcsType<any>> {
+	Proof: RawTransactionArgument<Proof>;
+	policy: RawTransactionArgument<string>;
+	request: RawTransactionArgument<string>;
+}
+export interface ProveOptions<Proof extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| ProveArguments<Proof>
+		| [
+				Proof: RawTransactionArgument<Proof>,
+				policy: RawTransactionArgument<string>,
+				request: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string, string];
+}
+/**
+ * Buyer action: follow the policy. Present the required "Proof" instance to get a
+ * receipt.
+ */
+export function prove<Proof extends BcsType<any>>(options: ProveOptions<Proof>) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [`${options.typeArguments[1]}`, null, null] satisfies (string | null)[];
+	const parameterNames = ['Proof', 'policy', 'request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'witness_rule',
+			function: 'prove',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/utils/index.ts

@@ -0,0 +1,234 @@
+import {
+	bcs,
+	BcsType,
+	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';
+
+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 interface GetManyOptions<
+	Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {},
+> extends HaneulClientTypes.GetObjectsOptions<Include> {
+	client: ClientWithCoreApi;
+}
+
+export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null {
+	const parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+
+	if ('u8' in parsedTag) {
+		return bcs.U8;
+	} else if ('u16' in parsedTag) {
+		return bcs.U16;
+	} else if ('u32' in parsedTag) {
+		return bcs.U32;
+	} else if ('u64' in parsedTag) {
+		return bcs.U64;
+	} else if ('u128' in parsedTag) {
+		return bcs.U128;
+	} else if ('u256' in parsedTag) {
+		return bcs.U256;
+	} else if ('address' in parsedTag) {
+		return bcs.Address;
+	} else if ('bool' in parsedTag) {
+		return bcs.Bool;
+	} else if ('vector' in parsedTag) {
+		const type = getPureBcsSchema(parsedTag.vector);
+		return type ? bcs.vector(type) : null;
+	} else if ('struct' in parsedTag) {
+		const structTag = parsedTag.struct;
+		const pkg = normalizeHaneulAddress(structTag.address);
+
+		if (pkg === MOVE_STDLIB_ADDRESS) {
+			if (
+				(structTag.module === 'ascii' || structTag.module === 'string') &&
+				structTag.name === 'String'
+			) {
+				return bcs.String;
+			}
+
+			if (structTag.module === 'option' && structTag.name === 'Option') {
+				const type = getPureBcsSchema(structTag.typeParams[0]);
+				return type ? bcs.option(type) : null;
+			}
+		}
+
+		if (
+			pkg === HANEUL_FRAMEWORK_ADDRESS &&
+			structTag.module === 'object' &&
+			(structTag.name === 'ID' || structTag.name === 'UID')
+		) {
+			return bcs.Address;
+		}
+	}
+
+	return null;
+}
+
+export function normalizeMoveArguments(
+	args: unknown[] | object,
+	argTypes: readonly (string | null)[],
+	parameterNames?: string[],
+) {
+	const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+	if (parameterNames && argLen !== parameterNames.length) {
+		throw new Error(
+			`Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`,
+		);
+	}
+
+	const normalizedArgs: TransactionArgument[] = [];
+
+	let index = 0;
+	for (const [i, argType] of argTypes.entries()) {
+		if (argType === '0x2::clock::Clock') {
+			normalizedArgs.push((tx) => tx.object.clock());
+			continue;
+		}
+
+		if (argType === '0x2::random::Random') {
+			normalizedArgs.push((tx) => tx.object.random());
+			continue;
+		}
+
+		if (argType === '0x2::deny_list::DenyList') {
+			normalizedArgs.push((tx) => tx.object.denyList());
+			continue;
+		}
+
+		if (argType === '0x3::haneul_system::HaneulSystemState') {
+			normalizedArgs.push((tx) => tx.object.system());
+			continue;
+		}
+
+		let arg;
+		if (Array.isArray(args)) {
+			if (index >= args.length) {
+				throw new Error(
+					`Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`,
+				);
+			}
+			arg = args[index];
+		} else {
+			if (!parameterNames) {
+				throw new Error(`Expected arguments to be passed as an array`);
+			}
+			const name = parameterNames[index];
+			arg = args[name as keyof typeof args];
+
+			if (arg === undefined) {
+				throw new Error(`Parameter ${name} is required`);
+			}
+		}
+
+		index += 1;
+
+		if (typeof arg === 'function' || isArgument(arg)) {
+			normalizedArgs.push(arg as TransactionArgument);
+			continue;
+		}
+
+		const type = argTypes[i];
+		const bcsType = type === null ? null : getPureBcsSchema(type);
+
+		if (bcsType) {
+			const bytes = bcsType.serialize(arg as never);
+			normalizedArgs.push((tx) => tx.pure(bytes));
+			continue;
+		} else if (typeof arg === 'string') {
+			normalizedArgs.push((tx) => tx.object(arg));
+			continue;
+		}
+
+		throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+	}
+
+	return normalizedArgs;
+}
+
+export class MoveStruct<
+	T extends Record<string, BcsType<any>>,
+	const Name extends string = string,
+> extends BcsStruct<T, Name> {
+	async get<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
+		objectId,
+		...options
+	}: GetOptions<Include>): Promise<
+		HaneulClientTypes.Object<Include & { content: true; json: true }> & {
+			json: BcsStruct<T>['$inferType'];
+		}
+	> {
+		const [res] = await this.getMany<Include>({
+			...options,
+			objectIds: [objectId],
+		});
+
+		return res;
+	}
+
+	async getMany<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
+		client,
+		...options
+	}: GetManyOptions<Include>): Promise<
+		Array<
+			HaneulClientTypes.Object<Include & { content: true; json: true }> & {
+				json: BcsStruct<T>['$inferType'];
+			}
+		>
+	> {
+		const response = (await client.core.getObjects({
+			...options,
+			include: {
+				...options.include,
+				content: true,
+			},
+		})) as HaneulClientTypes.GetObjectsResponse<Include & { content: true }>;
+
+		return response.objects.map((obj) => {
+			if (obj instanceof Error) {
+				throw obj;
+			}
+
+			return {
+				...obj,
+				json: this.parse(obj.content),
+			};
+		});
+	}
+}
+
+export class MoveEnum<
+	T extends Record<string, BcsType<any> | null>,
+	const Name extends string,
+> extends BcsEnum<T, Name> {}
+
+export class MoveTuple<
+	const T extends readonly BcsType<any>[],
+	const Name extends string,
+> extends BcsTuple<T, Name> {}
+
+function stringify(val: unknown) {
+	if (typeof val === 'object') {
+		return JSON.stringify(val, (val: unknown) => val);
+	}
+	if (typeof val === 'bigint') {
+		return val.toString();
+	}
+
+	return val;
+}