@mysten/kiosk 0.14.6 → 1.0.0

package/src/contracts/kiosk/deps/sui/kiosk.ts

@@ -0,0 +1,94 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Kiosk is a primitive for building safe, decentralized and trustless trading
+ * experiences. It allows storing and trading any types of assets as long as the
+ * creator of these assets implements a `TransferPolicy` for them.
+ *
+ * ### Principles and philosophy:
+ *
+ * - Kiosk provides guarantees of "true ownership"; - just like single owner
+ *   objects, assets stored in the Kiosk can only be managed by the Kiosk owner.
+ *   Only the owner can `place`, `take`, `list`, perform any other actions on
+ *   assets in the Kiosk.
+ *
+ * - Kiosk aims to be generic - allowing for a small set of default behaviors and
+ *   not imposing any restrictions on how the assets can be traded. The only
+ *   default scenario is a `list` + `purchase` flow; any other trading logic can be
+ *   implemented on top using the `list_with_purchase_cap` (and a matching
+ *   `purchase_with_cap`) flow.
+ *
+ * - For every transaction happening with a third party a `TransferRequest` is
+ *   created - this way creators are fully in control of the trading experience.
+ *
+ * ### Asset states in the Kiosk:
+ *
+ * - `placed` - An asset is `place`d into the Kiosk and can be `take`n out by the
+ *   Kiosk owner; it's freely tradable and modifiable via the `borrow_mut` and
+ *   `borrow_val` functions.
+ *
+ * - `locked` - Similar to `placed` except that `take` is disabled and the only way
+ *   to move the asset out of the Kiosk is to `list` it or `list_with_purchase_cap`
+ *   therefore performing a trade (issuing a `TransferRequest`). The check on the
+ *   `lock` function makes sure that the `TransferPolicy` exists to not lock the
+ *   item in a `Kiosk` forever.
+ *
+ * - `listed` - A `place`d or a `lock`ed item can be `list`ed for a fixed price
+ *   allowing anyone to `purchase` it from the Kiosk. While listed, an item can not
+ *   be taken or modified. However, an immutable borrow via `borrow` call is still
+ *   available. The `delist` function returns the asset to the previous state.
+ *
+ * - `listed_exclusively` - An item is listed via the `list_with_purchase_cap`
+ *   function (and a `PurchaseCap` is created). While listed this way, an item can
+ *   not be `delist`-ed unless a `PurchaseCap` is returned. All actions available
+ *   at this item state require a `PurchaseCap`:
+ *
+ * 1.  `purchase_with_cap` - to purchase the item for a price equal or higher than
+ *     the `min_price` set in the `PurchaseCap`.
+ * 2.  `return_purchase_cap` - to return the `PurchaseCap` and return the asset
+ *     into the previous state.
+ *
+ * When an item is listed exclusively it cannot be modified nor taken and losing a
+ * `PurchaseCap` would lock the item in the Kiosk forever. Therefore, it is
+ * recommended to only use `PurchaseCap` functionality in trusted applications and
+ * not use it for direct trading (eg sending to another account).
+ *
+ * ### Using multiple Transfer Policies for different "tracks":
+ *
+ * Every `purchase` or `purchase_with_purchase_cap` creates a `TransferRequest` hot
+ * potato which must be resolved in a matching `TransferPolicy` for the transaction
+ * to pass. While the default scenario implies that there should be a single
+ * `TransferPolicy<T>` for `T`; it is possible to have multiple, each one having
+ * its own set of rules.
+ *
+ * ### Examples:
+ *
+ * - I create one `TransferPolicy` with "Royalty Rule" for everyone
+ * - I create a special `TransferPolicy` for bearers of a "Club Membership" object
+ *   so they don't have to pay anything
+ * - I create and wrap a `TransferPolicy` so that players of my game can transfer
+ *   items between `Kiosk`s in game without any charge (and maybe not even paying
+ *   the price with a 0 SUI PurchaseCap)
+ *
+ * ```
+ * Kiosk -> (Item, TransferRequest)
+ * ... TransferRequest ------> Common Transfer Policy
+ * ... TransferRequest ------> In-game Wrapped Transfer Policy
+ * ... TransferRequest ------> Club Membership Transfer Policy
+ * ```
+ *
+ * See `transfer_policy` module for more details on how they function.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::kiosk';
+export const KioskOwnerCap = new MoveStruct({
+	name: `${$moduleName}::KioskOwnerCap`,
+	fields: {
+		id: bcs.Address,
+		for: bcs.Address,
+	},
+});

package/src/contracts/kiosk/deps/sui/object.ts

@@ -0,0 +1,15 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Sui object identifiers */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::object';
+export const UID = new MoveStruct({
+	name: `${$moduleName}::UID`,
+	fields: {
+		id: bcs.Address,
+	},
+});

package/src/contracts/kiosk/floor_price_rule.ts

@@ -0,0 +1,92 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Description: This module defines a Rule which sets the floor price for items of
+ * type T.
+ *
+ * Configuration:
+ *
+ * - floor_price - the floor price in MIST.
+ *
+ * Use cases:
+ *
+ * - Defining a floor price for all trades of type T.
+ * - Prevent trading of locked items with low amounts (e.g. by using purchase_cap).
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/kiosk::floor_price_rule';
+export const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const Config = new MoveStruct({
+	name: `${$moduleName}::Config`,
+	fields: {
+		floor_price: bcs.u64(),
+	},
+});
+export interface AddArguments {
+	policy: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+	floorPrice: RawTransactionArgument<number | bigint>;
+}
+export interface AddOptions {
+	package?: string;
+	arguments:
+		| AddArguments
+		| [
+				policy: RawTransactionArgument<string>,
+				cap: RawTransactionArgument<string>,
+				floorPrice: RawTransactionArgument<number | bigint>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * Creator action: Add the Floor Price Rule for the `T`. Pass in the
+ * `TransferPolicy`, `TransferPolicyCap` and `floor_price`.
+ */
+export function add(options: AddOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['policy', 'cap', 'floorPrice'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'floor_price_rule',
+			function: 'add',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ProveArguments {
+	policy: RawTransactionArgument<string>;
+	request: RawTransactionArgument<string>;
+}
+export interface ProveOptions {
+	package?: string;
+	arguments:
+		| ProveArguments
+		| [policy: RawTransactionArgument<string>, request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Buyer action: Prove that the amount is higher or equal to the floor_price. */
+export function prove(options: ProveOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['policy', 'request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'floor_price_rule',
+			function: 'prove',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/kiosk/kiosk_lock_rule.ts

@@ -0,0 +1,97 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Description: This module defines a Rule which forces buyers to put the purchased
+ * item into the Kiosk and lock it. The most common use case for the Rule is making
+ * sure an item never leaves Kiosks and has policies enforced on every transfer.
+ *
+ * Configuration:
+ *
+ * - None
+ *
+ * Use cases:
+ *
+ * - Enforcing policies on every trade
+ * - Making sure an item never leaves the Kiosk / certain ecosystem
+ *
+ * Notes:
+ *
+ * - "locking" mechanic disallows the `kiosk::take` function and forces the owner
+ *   to use `list` or `list_with_purchase_cap` methods if they wish to move the
+ *   item somewhere else.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/kiosk::kiosk_lock_rule';
+export const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const Config = new MoveStruct({
+	name: `${$moduleName}::Config`,
+	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];
+}
+/**
+ * Creator: Adds a `kiosk_lock_rule` Rule to the `TransferPolicy` forcing buyers to
+ * lock the item in a Kiosk on purchase.
+ */
+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: 'kiosk_lock_rule',
+			function: 'add',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ProveArguments {
+	request: RawTransactionArgument<string>;
+	kiosk: RawTransactionArgument<string>;
+}
+export interface ProveOptions {
+	package?: string;
+	arguments:
+		| ProveArguments
+		| [request: RawTransactionArgument<string>, kiosk: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/**
+ * Buyer: Prove the item was locked in the Kiosk to get the receipt and unblock the
+ * transfer request confirmation.
+ */
+export function prove(options: ProveOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['request', 'kiosk'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'kiosk_lock_rule',
+			function: 'prove',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/kiosk/personal_kiosk.ts

@@ -0,0 +1,295 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Description: This module provides a wrapper for the KioskOwnerCap that makes the
+ * Kiosk non-transferable and "owned".
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+import * as kiosk from './deps/sui/kiosk.js';
+const $moduleName = '@local-pkg/kiosk::personal_kiosk';
+export const PersonalKioskCap = new MoveStruct({
+	name: `${$moduleName}::PersonalKioskCap`,
+	fields: {
+		id: bcs.Address,
+		cap: bcs.option(kiosk.KioskOwnerCap),
+	},
+});
+export const Borrow = new MoveStruct({
+	name: `${$moduleName}::Borrow`,
+	fields: {
+		cap_id: bcs.Address,
+		owned_id: bcs.Address,
+	},
+});
+export const OwnerMarker = new MoveStruct({
+	name: `${$moduleName}::OwnerMarker`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const NewPersonalKiosk = new MoveStruct({
+	name: `${$moduleName}::NewPersonalKiosk`,
+	fields: {
+		kiosk_id: bcs.Address,
+	},
+});
+export interface DefaultArguments {
+	kiosk: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+}
+export interface DefaultOptions {
+	package?: string;
+	arguments:
+		| DefaultArguments
+		| [kiosk: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];
+}
+/** The default setup for the PersonalKioskCap. */
+export function _default(options: DefaultOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['kiosk', 'cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'default',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface NewArguments {
+	kiosk: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+}
+export interface NewOptions {
+	package?: string;
+	arguments:
+		| NewArguments
+		| [kiosk: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];
+}
+/**
+ * Wrap the KioskOwnerCap making the Kiosk "owned" and non-transferable. The
+ * `PersonalKioskCap` is returned to allow chaining within a PTB, but the value
+ * must be consumed by the `transfer_to_sender` call in any case.
+ */
+export function _new(options: NewOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['kiosk', 'cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'new',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface CreateForArguments {
+	kiosk: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+	recipient: RawTransactionArgument<string>;
+}
+export interface CreateForOptions {
+	package?: string;
+	arguments:
+		| CreateForArguments
+		| [
+				kiosk: RawTransactionArgument<string>,
+				cap: RawTransactionArgument<string>,
+				recipient: RawTransactionArgument<string>,
+		  ];
+}
+/**
+ * Create a `PersonalKiosk` for `recipient`. This is useful when (e.g.) an admin
+ * account wants to mint an asset with royalty enforcement on behalf of a user.
+ */
+export function createFor(options: CreateForOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['kiosk', 'cap', 'recipient'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'create_for',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface BorrowArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface BorrowOptions {
+	package?: string;
+	arguments: BorrowArguments | [self: RawTransactionArgument<string>];
+}
+/** Borrow the `KioskOwnerCap` from the `PersonalKioskCap` object. */
+export function borrow(options: BorrowOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'borrow',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface BorrowMutArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface BorrowMutOptions {
+	package?: string;
+	arguments: BorrowMutArguments | [self: RawTransactionArgument<string>];
+}
+/** Mutably borrow the `KioskOwnerCap` from the `PersonalKioskCap` object. */
+export function borrowMut(options: BorrowMutOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'borrow_mut',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface BorrowValArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface BorrowValOptions {
+	package?: string;
+	arguments: BorrowValArguments | [self: RawTransactionArgument<string>];
+}
+/**
+ * Borrow the `KioskOwnerCap` from the `PersonalKioskCap` object; `Borrow`
+ * hot-potato makes sure that the Cap is returned via `return_val` call.
+ */
+export function borrowVal(options: BorrowValOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'borrow_val',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface ReturnValArguments {
+	self: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+	borrow: RawTransactionArgument<string>;
+}
+export interface ReturnValOptions {
+	package?: string;
+	arguments:
+		| ReturnValArguments
+		| [
+				self: RawTransactionArgument<string>,
+				cap: RawTransactionArgument<string>,
+				borrow: RawTransactionArgument<string>,
+		  ];
+}
+/** Return the Cap to the PersonalKioskCap object. */
+export function returnVal(options: ReturnValOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null, null] satisfies (string | null)[];
+	const parameterNames = ['self', 'cap', 'borrow'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'return_val',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface IsPersonalArguments {
+	kiosk: RawTransactionArgument<string>;
+}
+export interface IsPersonalOptions {
+	package?: string;
+	arguments: IsPersonalArguments | [kiosk: RawTransactionArgument<string>];
+}
+/** Check if the Kiosk is "personal". */
+export function isPersonal(options: IsPersonalOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['kiosk'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'is_personal',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface OwnerArguments {
+	kiosk: RawTransactionArgument<string>;
+}
+export interface OwnerOptions {
+	package?: string;
+	arguments: OwnerArguments | [kiosk: RawTransactionArgument<string>];
+}
+/** Get the owner of the Kiosk if the Kiosk is "personal". Aborts otherwise. */
+export function owner(options: OwnerOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['kiosk'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'owner',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface TryOwnerArguments {
+	kiosk: RawTransactionArgument<string>;
+}
+export interface TryOwnerOptions {
+	package?: string;
+	arguments: TryOwnerArguments | [kiosk: RawTransactionArgument<string>];
+}
+/**
+ * Try to get the owner of the Kiosk if the Kiosk is "personal". Returns None
+ * otherwise.
+ */
+export function tryOwner(options: TryOwnerOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['kiosk'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'try_owner',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface TransferToSenderArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface TransferToSenderOptions {
+	package?: string;
+	arguments: TransferToSenderArguments | [self: RawTransactionArgument<string>];
+}
+/** Transfer the `PersonalKioskCap` to the transaction sender. */
+export function transferToSender(options: TransferToSenderOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk',
+			function: 'transfer_to_sender',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}

package/src/contracts/kiosk/personal_kiosk_rule.ts

@@ -0,0 +1,89 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Description: This module defines a Rule which checks that the Kiosk is
+ * "personal" meaning that the owner cannot change. By default, `KioskOwnerCap` can
+ * be transferred and owned by an application therefore the owner of the Kiosk is
+ * not fixed.
+ *
+ * Configuration:
+ *
+ * - None
+ *
+ * Use cases:
+ *
+ * - Strong royalty enforcement - personal Kiosks cannot be transferred with the
+ *   assets inside which means that the item will never change the owner.
+ *
+ * Notes:
+ *
+ * - Combination of `kiosk_lock_rule` and `personal_kiosk_rule` can be used to
+ *   enforce policies on every trade (item can be transferred only through a
+ *   trade + Kiosk is fixed to the owner).
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/kiosk::personal_kiosk_rule';
+export const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule`,
+	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];
+}
+/** Add the "owned" rule to the KioskOwnerCap. */
+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: 'personal_kiosk_rule',
+			function: 'add',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ProveArguments {
+	kiosk: RawTransactionArgument<string>;
+	request: RawTransactionArgument<string>;
+}
+export interface ProveOptions {
+	package?: string;
+	arguments:
+		| ProveArguments
+		| [kiosk: RawTransactionArgument<string>, request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/**
+ * Make sure that the destination Kiosk has the Owner key. Item is already placed
+ * by the time this check is performed - otherwise fails.
+ */
+export function prove(options: ProveOptions) {
+	const packageAddress = options.package ?? '@local-pkg/kiosk';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['kiosk', 'request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'personal_kiosk_rule',
+			function: 'prove',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}