@mysten/kiosk 0.14.6 → 1.0.1

package/dist/contracts/kiosk/deps/sui/kiosk.mjs.map

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

package/dist/contracts/kiosk/floor_price_rule.mjs

@@ -0,0 +1,70 @@
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/kiosk/floor_price_rule.ts
+/**************************************************************
+* 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).
+*/
+const $moduleName = "@local-pkg/kiosk::floor_price_rule";
+const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule`,
+	fields: { dummy_field: bcs.bool() }
+});
+const Config = new MoveStruct({
+	name: `${$moduleName}::Config`,
+	fields: { floor_price: bcs.u64() }
+});
+/**
+* Creator action: Add the Floor Price Rule for the `T`. Pass in the
+* `TransferPolicy`, `TransferPolicyCap` and `floor_price`.
+*/
+function add(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"policy",
+		"cap",
+		"floorPrice"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "floor_price_rule",
+		function: "add",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Buyer action: Prove that the amount is higher or equal to the floor_price. */
+function prove(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["policy", "request"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "floor_price_rule",
+		function: "prove",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+
+//#endregion
+export { add, prove };
+//# sourceMappingURL=floor_price_rule.mjs.map

package/dist/contracts/kiosk/floor_price_rule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor_price_rule.mjs","names":[],"sources":["../../../src/contracts/kiosk/floor_price_rule.ts"],"sourcesContent":["/**************************************************************\n * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *\n **************************************************************/\n\n/**\n * Description: This module defines a Rule which sets the floor price for items of\n * type T.\n *\n * Configuration:\n *\n * - floor_price - the floor price in MIST.\n *\n * Use cases:\n *\n * - Defining a floor price for all trades of type T.\n * - Prevent trading of locked items with low amounts (e.g. by using purchase_cap).\n */\n\nimport { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';\nimport { bcs } from '@mysten/sui/bcs';\nimport { type Transaction } from '@mysten/sui/transactions';\nconst $moduleName = '@local-pkg/kiosk::floor_price_rule';\nexport const Rule = new MoveStruct({\n\tname: `${$moduleName}::Rule`,\n\tfields: {\n\t\tdummy_field: bcs.bool(),\n\t},\n});\nexport const Config = new MoveStruct({\n\tname: `${$moduleName}::Config`,\n\tfields: {\n\t\tfloor_price: bcs.u64(),\n\t},\n});\nexport interface AddArguments {\n\tpolicy: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n\tfloorPrice: RawTransactionArgument<number | bigint>;\n}\nexport interface AddOptions {\n\tpackage?: string;\n\targuments:\n\t\t| AddArguments\n\t\t| [\n\t\t\t\tpolicy: RawTransactionArgument<string>,\n\t\t\t\tcap: RawTransactionArgument<string>,\n\t\t\t\tfloorPrice: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\ttypeArguments: [string];\n}\n/**\n * Creator action: Add the Floor Price Rule for the `T`. Pass in the\n * `TransferPolicy`, `TransferPolicyCap` and `floor_price`.\n */\nexport function add(options: AddOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null, 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['policy', 'cap', 'floorPrice'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'floor_price_rule',\n\t\t\tfunction: 'add',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface ProveArguments {\n\tpolicy: RawTransactionArgument<string>;\n\trequest: RawTransactionArgument<string>;\n}\nexport interface ProveOptions {\n\tpackage?: string;\n\targuments:\n\t\t| ProveArguments\n\t\t| [policy: RawTransactionArgument<string>, request: RawTransactionArgument<string>];\n\ttypeArguments: [string];\n}\n/** Buyer action: Prove that the amount is higher or equal to the floor_price. */\nexport function prove(options: ProveOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null] satisfies (string | null)[];\n\tconst parameterNames = ['policy', 'request'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'floor_price_rule',\n\t\t\tfunction: 'prove',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,cAAc;AACpB,MAAa,OAAO,IAAI,WAAW;CAClC,MAAM,GAAG,YAAY;CACrB,QAAQ,EACP,aAAa,IAAI,MAAM,EACvB;CACD,CAAC;AACF,MAAa,SAAS,IAAI,WAAW;CACpC,MAAM,GAAG,YAAY;CACrB,QAAQ,EACP,aAAa,IAAI,KAAK,EACtB;CACD,CAAC;;;;;AAqBF,SAAgB,IAAI,SAAqB;CACxC,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB;EAAC;EAAM;EAAM;EAAM;CAC1C,MAAM,iBAAiB;EAAC;EAAU;EAAO;EAAa;AACtD,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC;;;AAcJ,SAAgB,MAAM,SAAuB;CAC5C,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,MAAM,KAAK;CACnC,MAAM,iBAAiB,CAAC,UAAU,UAAU;AAC5C,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC"}

package/dist/contracts/kiosk/kiosk_lock_rule.mjs

@@ -0,0 +1,72 @@
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/kiosk/kiosk_lock_rule.ts
+/**************************************************************
+* 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.
+*/
+const $moduleName = "@local-pkg/kiosk::kiosk_lock_rule";
+const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule`,
+	fields: { dummy_field: bcs.bool() }
+});
+const Config = new MoveStruct({
+	name: `${$moduleName}::Config`,
+	fields: { dummy_field: bcs.bool() }
+});
+/**
+* Creator: Adds a `kiosk_lock_rule` Rule to the `TransferPolicy` forcing buyers to
+* lock the item in a Kiosk on purchase.
+*/
+function add(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["policy", "cap"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "kiosk_lock_rule",
+		function: "add",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Buyer: Prove the item was locked in the Kiosk to get the receipt and unblock the
+* transfer request confirmation.
+*/
+function prove(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["request", "kiosk"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "kiosk_lock_rule",
+		function: "prove",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+
+//#endregion
+export { add, prove };
+//# sourceMappingURL=kiosk_lock_rule.mjs.map

package/dist/contracts/kiosk/kiosk_lock_rule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kiosk_lock_rule.mjs","names":[],"sources":["../../../src/contracts/kiosk/kiosk_lock_rule.ts"],"sourcesContent":["/**************************************************************\n * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *\n **************************************************************/\n\n/**\n * Description: This module defines a Rule which forces buyers to put the purchased\n * item into the Kiosk and lock it. The most common use case for the Rule is making\n * sure an item never leaves Kiosks and has policies enforced on every transfer.\n *\n * Configuration:\n *\n * - None\n *\n * Use cases:\n *\n * - Enforcing policies on every trade\n * - Making sure an item never leaves the Kiosk / certain ecosystem\n *\n * Notes:\n *\n * - \"locking\" mechanic disallows the `kiosk::take` function and forces the owner\n *   to use `list` or `list_with_purchase_cap` methods if they wish to move the\n *   item somewhere else.\n */\n\nimport { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';\nimport { bcs } from '@mysten/sui/bcs';\nimport { type Transaction } from '@mysten/sui/transactions';\nconst $moduleName = '@local-pkg/kiosk::kiosk_lock_rule';\nexport const Rule = new MoveStruct({\n\tname: `${$moduleName}::Rule`,\n\tfields: {\n\t\tdummy_field: bcs.bool(),\n\t},\n});\nexport const Config = new MoveStruct({\n\tname: `${$moduleName}::Config`,\n\tfields: {\n\t\tdummy_field: bcs.bool(),\n\t},\n});\nexport interface AddArguments {\n\tpolicy: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n}\nexport interface AddOptions {\n\tpackage?: string;\n\targuments:\n\t\t| AddArguments\n\t\t| [policy: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];\n\ttypeArguments: [string];\n}\n/**\n * Creator: Adds a `kiosk_lock_rule` Rule to the `TransferPolicy` forcing buyers to\n * lock the item in a Kiosk on purchase.\n */\nexport function add(options: AddOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null] satisfies (string | null)[];\n\tconst parameterNames = ['policy', 'cap'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'kiosk_lock_rule',\n\t\t\tfunction: 'add',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface ProveArguments {\n\trequest: RawTransactionArgument<string>;\n\tkiosk: RawTransactionArgument<string>;\n}\nexport interface ProveOptions {\n\tpackage?: string;\n\targuments:\n\t\t| ProveArguments\n\t\t| [request: RawTransactionArgument<string>, kiosk: RawTransactionArgument<string>];\n\ttypeArguments: [string];\n}\n/**\n * Buyer: Prove the item was locked in the Kiosk to get the receipt and unblock the\n * transfer request confirmation.\n */\nexport function prove(options: ProveOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null] satisfies (string | null)[];\n\tconst parameterNames = ['request', 'kiosk'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'kiosk_lock_rule',\n\t\t\tfunction: 'prove',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAM,cAAc;AACpB,MAAa,OAAO,IAAI,WAAW;CAClC,MAAM,GAAG,YAAY;CACrB,QAAQ,EACP,aAAa,IAAI,MAAM,EACvB;CACD,CAAC;AACF,MAAa,SAAS,IAAI,WAAW;CACpC,MAAM,GAAG,YAAY;CACrB,QAAQ,EACP,aAAa,IAAI,MAAM,EACvB;CACD,CAAC;;;;;AAgBF,SAAgB,IAAI,SAAqB;CACxC,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,MAAM,KAAK;CACnC,MAAM,iBAAiB,CAAC,UAAU,MAAM;AACxC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC;;;;;;AAiBJ,SAAgB,MAAM,SAAuB;CAC5C,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,MAAM,KAAK;CACnC,MAAM,iBAAiB,CAAC,WAAW,QAAQ;AAC3C,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC"}

package/dist/contracts/kiosk/personal_kiosk.mjs

@@ -0,0 +1,102 @@
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { KioskOwnerCap } from "./deps/sui/kiosk.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/kiosk/personal_kiosk.ts
+/**************************************************************
+* 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".
+*/
+const $moduleName = "@local-pkg/kiosk::personal_kiosk";
+const PersonalKioskCap = new MoveStruct({
+	name: `${$moduleName}::PersonalKioskCap`,
+	fields: {
+		id: bcs.Address,
+		cap: bcs.option(KioskOwnerCap)
+	}
+});
+const Borrow = new MoveStruct({
+	name: `${$moduleName}::Borrow`,
+	fields: {
+		cap_id: bcs.Address,
+		owned_id: bcs.Address
+	}
+});
+const OwnerMarker = new MoveStruct({
+	name: `${$moduleName}::OwnerMarker`,
+	fields: { dummy_field: bcs.bool() }
+});
+const NewPersonalKiosk = new MoveStruct({
+	name: `${$moduleName}::NewPersonalKiosk`,
+	fields: { kiosk_id: bcs.Address }
+});
+/**
+* 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.
+*/
+function _new(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["kiosk", "cap"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "personal_kiosk",
+		function: "new",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Borrow the `KioskOwnerCap` from the `PersonalKioskCap` object; `Borrow`
+* hot-potato makes sure that the Cap is returned via `return_val` call.
+*/
+function borrowVal(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "personal_kiosk",
+		function: "borrow_val",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/** Return the Cap to the PersonalKioskCap object. */
+function returnVal(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"self",
+		"cap",
+		"borrow"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "personal_kiosk",
+		function: "return_val",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/** Transfer the `PersonalKioskCap` to the transaction sender. */
+function transferToSender(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "personal_kiosk",
+		function: "transfer_to_sender",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+
+//#endregion
+export { PersonalKioskCap, _new, borrowVal, returnVal, transferToSender };
+//# sourceMappingURL=personal_kiosk.mjs.map

package/dist/contracts/kiosk/personal_kiosk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"personal_kiosk.mjs","names":["kiosk.KioskOwnerCap"],"sources":["../../../src/contracts/kiosk/personal_kiosk.ts"],"sourcesContent":["/**************************************************************\n * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *\n **************************************************************/\n\n/**\n * Description: This module provides a wrapper for the KioskOwnerCap that makes the\n * Kiosk non-transferable and \"owned\".\n */\n\nimport { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';\nimport { bcs } from '@mysten/sui/bcs';\nimport { type Transaction } from '@mysten/sui/transactions';\nimport * as kiosk from './deps/sui/kiosk.js';\nconst $moduleName = '@local-pkg/kiosk::personal_kiosk';\nexport const PersonalKioskCap = new MoveStruct({\n\tname: `${$moduleName}::PersonalKioskCap`,\n\tfields: {\n\t\tid: bcs.Address,\n\t\tcap: bcs.option(kiosk.KioskOwnerCap),\n\t},\n});\nexport const Borrow = new MoveStruct({\n\tname: `${$moduleName}::Borrow`,\n\tfields: {\n\t\tcap_id: bcs.Address,\n\t\towned_id: bcs.Address,\n\t},\n});\nexport const OwnerMarker = new MoveStruct({\n\tname: `${$moduleName}::OwnerMarker`,\n\tfields: {\n\t\tdummy_field: bcs.bool(),\n\t},\n});\nexport const NewPersonalKiosk = new MoveStruct({\n\tname: `${$moduleName}::NewPersonalKiosk`,\n\tfields: {\n\t\tkiosk_id: bcs.Address,\n\t},\n});\nexport interface DefaultArguments {\n\tkiosk: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n}\nexport interface DefaultOptions {\n\tpackage?: string;\n\targuments:\n\t\t| DefaultArguments\n\t\t| [kiosk: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];\n}\n/** The default setup for the PersonalKioskCap. */\nexport function _default(options: DefaultOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null] satisfies (string | null)[];\n\tconst parameterNames = ['kiosk', 'cap'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'default',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface NewArguments {\n\tkiosk: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n}\nexport interface NewOptions {\n\tpackage?: string;\n\targuments:\n\t\t| NewArguments\n\t\t| [kiosk: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];\n}\n/**\n * Wrap the KioskOwnerCap making the Kiosk \"owned\" and non-transferable. The\n * `PersonalKioskCap` is returned to allow chaining within a PTB, but the value\n * must be consumed by the `transfer_to_sender` call in any case.\n */\nexport function _new(options: NewOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null] satisfies (string | null)[];\n\tconst parameterNames = ['kiosk', 'cap'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'new',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface CreateForArguments {\n\tkiosk: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n\trecipient: RawTransactionArgument<string>;\n}\nexport interface CreateForOptions {\n\tpackage?: string;\n\targuments:\n\t\t| CreateForArguments\n\t\t| [\n\t\t\t\tkiosk: RawTransactionArgument<string>,\n\t\t\t\tcap: RawTransactionArgument<string>,\n\t\t\t\trecipient: RawTransactionArgument<string>,\n\t\t  ];\n}\n/**\n * Create a `PersonalKiosk` for `recipient`. This is useful when (e.g.) an admin\n * account wants to mint an asset with royalty enforcement on behalf of a user.\n */\nexport function createFor(options: CreateForOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null, 'address'] satisfies (string | null)[];\n\tconst parameterNames = ['kiosk', 'cap', 'recipient'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'create_for',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface BorrowArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface BorrowOptions {\n\tpackage?: string;\n\targuments: BorrowArguments | [self: RawTransactionArgument<string>];\n}\n/** Borrow the `KioskOwnerCap` from the `PersonalKioskCap` object. */\nexport function borrow(options: BorrowOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'borrow',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface BorrowMutArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface BorrowMutOptions {\n\tpackage?: string;\n\targuments: BorrowMutArguments | [self: RawTransactionArgument<string>];\n}\n/** Mutably borrow the `KioskOwnerCap` from the `PersonalKioskCap` object. */\nexport function borrowMut(options: BorrowMutOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'borrow_mut',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface BorrowValArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface BorrowValOptions {\n\tpackage?: string;\n\targuments: BorrowValArguments | [self: RawTransactionArgument<string>];\n}\n/**\n * Borrow the `KioskOwnerCap` from the `PersonalKioskCap` object; `Borrow`\n * hot-potato makes sure that the Cap is returned via `return_val` call.\n */\nexport function borrowVal(options: BorrowValOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'borrow_val',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface ReturnValArguments {\n\tself: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n\tborrow: RawTransactionArgument<string>;\n}\nexport interface ReturnValOptions {\n\tpackage?: string;\n\targuments:\n\t\t| ReturnValArguments\n\t\t| [\n\t\t\t\tself: RawTransactionArgument<string>,\n\t\t\t\tcap: RawTransactionArgument<string>,\n\t\t\t\tborrow: RawTransactionArgument<string>,\n\t\t  ];\n}\n/** Return the Cap to the PersonalKioskCap object. */\nexport function returnVal(options: ReturnValOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null, null] satisfies (string | null)[];\n\tconst parameterNames = ['self', 'cap', 'borrow'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'return_val',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface IsPersonalArguments {\n\tkiosk: RawTransactionArgument<string>;\n}\nexport interface IsPersonalOptions {\n\tpackage?: string;\n\targuments: IsPersonalArguments | [kiosk: RawTransactionArgument<string>];\n}\n/** Check if the Kiosk is \"personal\". */\nexport function isPersonal(options: IsPersonalOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['kiosk'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'is_personal',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface OwnerArguments {\n\tkiosk: RawTransactionArgument<string>;\n}\nexport interface OwnerOptions {\n\tpackage?: string;\n\targuments: OwnerArguments | [kiosk: RawTransactionArgument<string>];\n}\n/** Get the owner of the Kiosk if the Kiosk is \"personal\". Aborts otherwise. */\nexport function owner(options: OwnerOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['kiosk'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'owner',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface TryOwnerArguments {\n\tkiosk: RawTransactionArgument<string>;\n}\nexport interface TryOwnerOptions {\n\tpackage?: string;\n\targuments: TryOwnerArguments | [kiosk: RawTransactionArgument<string>];\n}\n/**\n * Try to get the owner of the Kiosk if the Kiosk is \"personal\". Returns None\n * otherwise.\n */\nexport function tryOwner(options: TryOwnerOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['kiosk'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'try_owner',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface TransferToSenderArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface TransferToSenderOptions {\n\tpackage?: string;\n\targuments: TransferToSenderArguments | [self: RawTransactionArgument<string>];\n}\n/** Transfer the `PersonalKioskCap` to the transaction sender. */\nexport function transferToSender(options: TransferToSenderOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk',\n\t\t\tfunction: 'transfer_to_sender',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAM,cAAc;AACpB,MAAa,mBAAmB,IAAI,WAAW;CAC9C,MAAM,GAAG,YAAY;CACrB,QAAQ;EACP,IAAI,IAAI;EACR,KAAK,IAAI,OAAOA,cAAoB;EACpC;CACD,CAAC;AACF,MAAa,SAAS,IAAI,WAAW;CACpC,MAAM,GAAG,YAAY;CACrB,QAAQ;EACP,QAAQ,IAAI;EACZ,UAAU,IAAI;EACd;CACD,CAAC;AACF,MAAa,cAAc,IAAI,WAAW;CACzC,MAAM,GAAG,YAAY;CACrB,QAAQ,EACP,aAAa,IAAI,MAAM,EACvB;CACD,CAAC;AACF,MAAa,mBAAmB,IAAI,WAAW;CAC9C,MAAM,GAAG,YAAY;CACrB,QAAQ,EACP,UAAU,IAAI,SACd;CACD,CAAC;;;;;;AAuCF,SAAgB,KAAK,SAAqB;CACzC,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,MAAM,KAAK;CACnC,MAAM,iBAAiB,CAAC,SAAS,MAAM;AACvC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC;;;;;;AAoFJ,SAAgB,UAAU,SAA2B;CACpD,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,KAAK;CAC7B,MAAM,iBAAiB,CAAC,OAAO;AAC/B,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC;;;AAkBJ,SAAgB,UAAU,SAA2B;CACpD,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB;EAAC;EAAM;EAAM;EAAK;CACzC,MAAM,iBAAiB;EAAC;EAAQ;EAAO;EAAS;AAChD,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC;;;AAyEJ,SAAgB,iBAAiB,SAAkC;CAClE,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,KAAK;CAC7B,MAAM,iBAAiB,CAAC,OAAO;AAC/B,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC"}

package/dist/contracts/kiosk/personal_kiosk_rule.mjs

@@ -0,0 +1,66 @@
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/kiosk/personal_kiosk_rule.ts
+/**************************************************************
+* 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).
+*/
+const $moduleName = "@local-pkg/kiosk::personal_kiosk_rule";
+const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule`,
+	fields: { dummy_field: bcs.bool() }
+});
+/** Add the "owned" rule to the KioskOwnerCap. */
+function add(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["policy", "cap"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "personal_kiosk_rule",
+		function: "add",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Make sure that the destination Kiosk has the Owner key. Item is already placed
+* by the time this check is performed - otherwise fails.
+*/
+function prove(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["kiosk", "request"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "personal_kiosk_rule",
+		function: "prove",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+
+//#endregion
+export { add, prove };
+//# sourceMappingURL=personal_kiosk_rule.mjs.map

package/dist/contracts/kiosk/personal_kiosk_rule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"personal_kiosk_rule.mjs","names":[],"sources":["../../../src/contracts/kiosk/personal_kiosk_rule.ts"],"sourcesContent":["/**************************************************************\n * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *\n **************************************************************/\n\n/**\n * Description: This module defines a Rule which checks that the Kiosk is\n * \"personal\" meaning that the owner cannot change. By default, `KioskOwnerCap` can\n * be transferred and owned by an application therefore the owner of the Kiosk is\n * not fixed.\n *\n * Configuration:\n *\n * - None\n *\n * Use cases:\n *\n * - Strong royalty enforcement - personal Kiosks cannot be transferred with the\n *   assets inside which means that the item will never change the owner.\n *\n * Notes:\n *\n * - Combination of `kiosk_lock_rule` and `personal_kiosk_rule` can be used to\n *   enforce policies on every trade (item can be transferred only through a\n *   trade + Kiosk is fixed to the owner).\n */\n\nimport { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';\nimport { bcs } from '@mysten/sui/bcs';\nimport { type Transaction } from '@mysten/sui/transactions';\nconst $moduleName = '@local-pkg/kiosk::personal_kiosk_rule';\nexport const Rule = new MoveStruct({\n\tname: `${$moduleName}::Rule`,\n\tfields: {\n\t\tdummy_field: bcs.bool(),\n\t},\n});\nexport interface AddArguments {\n\tpolicy: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n}\nexport interface AddOptions {\n\tpackage?: string;\n\targuments:\n\t\t| AddArguments\n\t\t| [policy: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];\n\ttypeArguments: [string];\n}\n/** Add the \"owned\" rule to the KioskOwnerCap. */\nexport function add(options: AddOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null] satisfies (string | null)[];\n\tconst parameterNames = ['policy', 'cap'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk_rule',\n\t\t\tfunction: 'add',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface ProveArguments {\n\tkiosk: RawTransactionArgument<string>;\n\trequest: RawTransactionArgument<string>;\n}\nexport interface ProveOptions {\n\tpackage?: string;\n\targuments:\n\t\t| ProveArguments\n\t\t| [kiosk: RawTransactionArgument<string>, request: RawTransactionArgument<string>];\n\ttypeArguments: [string];\n}\n/**\n * Make sure that the destination Kiosk has the Owner key. Item is already placed\n * by the time this check is performed - otherwise fails.\n */\nexport function prove(options: ProveOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null] satisfies (string | null)[];\n\tconst parameterNames = ['kiosk', 'request'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'personal_kiosk_rule',\n\t\t\tfunction: 'prove',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAM,cAAc;AACpB,MAAa,OAAO,IAAI,WAAW;CAClC,MAAM,GAAG,YAAY;CACrB,QAAQ,EACP,aAAa,IAAI,MAAM,EACvB;CACD,CAAC;;AAaF,SAAgB,IAAI,SAAqB;CACxC,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,MAAM,KAAK;CACnC,MAAM,iBAAiB,CAAC,UAAU,MAAM;AACxC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC;;;;;;AAiBJ,SAAgB,MAAM,SAAuB;CAC5C,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,MAAM,KAAK;CACnC,MAAM,iBAAiB,CAAC,SAAS,UAAU;AAC3C,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC"}

package/dist/contracts/kiosk/royalty_rule.mjs

@@ -0,0 +1,115 @@
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/kiosk/royalty_rule.ts
+/**************************************************************
+* 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.
+*/
+const $moduleName = "@local-pkg/kiosk::royalty_rule";
+const Rule = new MoveStruct({
+	name: `${$moduleName}::Rule`,
+	fields: { dummy_field: bcs.bool() }
+});
+const Config = new MoveStruct({
+	name: `${$moduleName}::Config`,
+	fields: {
+		amount_bp: bcs.u16(),
+		min_amount: bcs.u64()
+	}
+});
+/**
+* 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`.
+*/
+function add(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [
+		null,
+		null,
+		"u16",
+		"u64"
+	];
+	const parameterNames = [
+		"policy",
+		"cap",
+		"amountBp",
+		"minAmount"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "royalty_rule",
+		function: "add",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Buyer action: Pay the royalty fee for the transfer. */
+function pay(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"policy",
+		"request",
+		"payment"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "royalty_rule",
+		function: "pay",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* 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.
+*/
+function feeAmount(options) {
+	const packageAddress = options.package ?? "@local-pkg/kiosk";
+	const argumentsTypes = [null, "u64"];
+	const parameterNames = ["policy", "paid"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "royalty_rule",
+		function: "fee_amount",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+
+//#endregion
+export { add, feeAmount, pay };
+//# sourceMappingURL=royalty_rule.mjs.map

package/dist/contracts/kiosk/royalty_rule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"royalty_rule.mjs","names":[],"sources":["../../../src/contracts/kiosk/royalty_rule.ts"],"sourcesContent":["/**************************************************************\n * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *\n **************************************************************/\n\n/**\n * Description: This module defines a Rule which requires a payment on a purchase.\n * The payment amount can be either a fixed amount (min_amount) or a percentage of\n * the purchase price (amount_bp). Or both: the higher of the two is used.\n *\n * Configuration:\n *\n * - amount_bp - the percentage of the purchase price to be paid as a fee,\n *   denominated in basis points (100_00 = 100%, 1 = 0.01%).\n * - min_amount - the minimum amount to be paid as a fee if the relative amount is\n *   lower than this setting.\n *\n * Use cases:\n *\n * - Percentage-based Royalty fee for the creator of the NFT.\n * - Fixed commission fee on a trade.\n * - A mix of both: the higher of the two is used.\n *\n * Notes:\n *\n * - To use it as a fixed commission set the `amount_bp` to 0 and use the\n *   `min_amount` to set the fixed amount.\n * - To use it as a percentage-based fee set the `min_amount` to 0 and use the\n *   `amount_bp` to set the percentage.\n * - To use it as a mix of both set the `min_amount` to the min amount acceptable\n *   and the `amount_bp` to the percentage of the purchase price. The higher of the\n *   two will be used.\n */\n\nimport { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';\nimport { bcs } from '@mysten/sui/bcs';\nimport { type Transaction } from '@mysten/sui/transactions';\nconst $moduleName = '@local-pkg/kiosk::royalty_rule';\nexport const Rule = new MoveStruct({\n\tname: `${$moduleName}::Rule`,\n\tfields: {\n\t\tdummy_field: bcs.bool(),\n\t},\n});\nexport const Config = new MoveStruct({\n\tname: `${$moduleName}::Config`,\n\tfields: {\n\t\tamount_bp: bcs.u16(),\n\t\tmin_amount: bcs.u64(),\n\t},\n});\nexport interface AddArguments {\n\tpolicy: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n\tamountBp: RawTransactionArgument<number>;\n\tminAmount: RawTransactionArgument<number | bigint>;\n}\nexport interface AddOptions {\n\tpackage?: string;\n\targuments:\n\t\t| AddArguments\n\t\t| [\n\t\t\t\tpolicy: RawTransactionArgument<string>,\n\t\t\t\tcap: RawTransactionArgument<string>,\n\t\t\t\tamountBp: RawTransactionArgument<number>,\n\t\t\t\tminAmount: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\ttypeArguments: [string];\n}\n/**\n * Creator action: Add the Royalty Rule for the `T`. Pass in the `TransferPolicy`,\n * `TransferPolicyCap` and the configuration for the policy: `amount_bp` and\n * `min_amount`.\n */\nexport function add(options: AddOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null, 'u16', 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['policy', 'cap', 'amountBp', 'minAmount'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'royalty_rule',\n\t\t\tfunction: 'add',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface PayArguments {\n\tpolicy: RawTransactionArgument<string>;\n\trequest: RawTransactionArgument<string>;\n\tpayment: RawTransactionArgument<string>;\n}\nexport interface PayOptions {\n\tpackage?: string;\n\targuments:\n\t\t| PayArguments\n\t\t| [\n\t\t\t\tpolicy: RawTransactionArgument<string>,\n\t\t\t\trequest: RawTransactionArgument<string>,\n\t\t\t\tpayment: RawTransactionArgument<string>,\n\t\t  ];\n\ttypeArguments: [string];\n}\n/** Buyer action: Pay the royalty fee for the transfer. */\nexport function pay(options: PayOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, null, null] satisfies (string | null)[];\n\tconst parameterNames = ['policy', 'request', 'payment'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'royalty_rule',\n\t\t\tfunction: 'pay',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface FeeAmountArguments {\n\tpolicy: RawTransactionArgument<string>;\n\tpaid: RawTransactionArgument<number | bigint>;\n}\nexport interface FeeAmountOptions {\n\tpackage?: string;\n\targuments:\n\t\t| FeeAmountArguments\n\t\t| [policy: RawTransactionArgument<string>, paid: RawTransactionArgument<number | bigint>];\n\ttypeArguments: [string];\n}\n/**\n * Helper function to calculate the amount to be paid for the transfer. Can be used\n * dry-runned to estimate the fee amount based on the Kiosk listing price.\n */\nexport function feeAmount(options: FeeAmountOptions) {\n\tconst packageAddress = options.package ?? '@local-pkg/kiosk';\n\tconst argumentsTypes = [null, 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['policy', 'paid'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'royalty_rule',\n\t\t\tfunction: 'fee_amount',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAM,cAAc;AACpB,MAAa,OAAO,IAAI,WAAW;CAClC,MAAM,GAAG,YAAY;CACrB,QAAQ,EACP,aAAa,IAAI,MAAM,EACvB;CACD,CAAC;AACF,MAAa,SAAS,IAAI,WAAW;CACpC,MAAM,GAAG,YAAY;CACrB,QAAQ;EACP,WAAW,IAAI,KAAK;EACpB,YAAY,IAAI,KAAK;EACrB;CACD,CAAC;;;;;;AAwBF,SAAgB,IAAI,SAAqB;CACxC,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB;EAAC;EAAM;EAAM;EAAO;EAAM;CACjD,MAAM,iBAAiB;EAAC;EAAU;EAAO;EAAY;EAAY;AACjE,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC;;;AAmBJ,SAAgB,IAAI,SAAqB;CACxC,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB;EAAC;EAAM;EAAM;EAAK;CACzC,MAAM,iBAAiB;EAAC;EAAU;EAAW;EAAU;AACvD,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC;;;;;;AAiBJ,SAAgB,UAAU,SAA2B;CACpD,MAAM,iBAAiB,QAAQ,WAAW;CAC1C,MAAM,iBAAiB,CAAC,MAAM,MAAM;CACpC,MAAM,iBAAiB,CAAC,UAAU,OAAO;AACzC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,eAAe,QAAQ;EACvB,CAAC"}

package/dist/contracts/utils/index.mjs

@@ -0,0 +1,118 @@
+import { BcsStruct, TypeTagSerializer, bcs } from "@mysten/sui/bcs";
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+import { isArgument } from "@mysten/sui/transactions";
+
+//#region src/contracts/utils/index.ts
+const MOVE_STDLIB_ADDRESS = normalizeSuiAddress("0x1");
+const SUI_FRAMEWORK_ADDRESS$1 = normalizeSuiAddress("0x2");
+function getPureBcsSchema(typeTag) {
+	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 = normalizeSuiAddress(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 === SUI_FRAMEWORK_ADDRESS$1 && structTag.module === "object" && (structTag.name === "ID" || structTag.name === "UID")) return bcs.Address;
+	}
+	return null;
+}
+function normalizeMoveArguments(args, argTypes, parameterNames) {
+	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 = [];
+	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::sui_system::SuiSystemState") {
+			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];
+			if (arg === void 0) throw new Error(`Parameter ${name} is required`);
+		}
+		index += 1;
+		if (typeof arg === "function" || isArgument(arg)) {
+			normalizedArgs.push(arg);
+			continue;
+		}
+		const type = argTypes[i];
+		const bcsType = type === null ? null : getPureBcsSchema(type);
+		if (bcsType) {
+			const bytes = bcsType.serialize(arg);
+			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;
+}
+var MoveStruct = class extends BcsStruct {
+	async get({ objectId, ...options }) {
+		const [res] = await this.getMany({
+			...options,
+			objectIds: [objectId]
+		});
+		return res;
+	}
+	async getMany({ client, ...options }) {
+		return (await client.core.getObjects({
+			...options,
+			include: {
+				...options.include,
+				content: true
+			}
+		})).objects.map((obj) => {
+			if (obj instanceof Error) throw obj;
+			return {
+				...obj,
+				json: this.parse(obj.content)
+			};
+		});
+	}
+};
+function stringify(val) {
+	if (typeof val === "object") return JSON.stringify(val, (val$1) => val$1);
+	if (typeof val === "bigint") return val.toString();
+	return val;
+}
+
+//#endregion
+export { MoveStruct, normalizeMoveArguments };
+//# sourceMappingURL=index.mjs.map