@mysten/kiosk 0.6.0 → 0.7.1

package/src/query/transfer-policy.ts

@@ -2,8 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { SuiClient } from '@mysten/sui.js/client';
+import { isValidSuiAddress } from '@mysten/sui.js/utils';
+
 import { bcs } from '../bcs';
-import { TRANSFER_POLICY_CREATED_EVENT, TRANSFER_POLICY_TYPE, TransferPolicy } from '../types';
+import {
+	TRANSFER_POLICY_CAP_TYPE,
+	TRANSFER_POLICY_CREATED_EVENT,
+	TRANSFER_POLICY_TYPE,
+	TransferPolicy,
+	TransferPolicyCap,
+} from '../types';
+import { getAllOwnedObjects, parseTransferPolicyCapObject } from '../utils';
 
 /**
  * Searches the `TransferPolicy`-s for the given type. The seach is performed via
@@ -40,7 +49,7 @@ export async function queryTransferPolicy(
 				throw new Error(`Invalid policy: ${policy?.objectId}, expected object, got package`);
 			}
 
-			let parsed = bcs.de(TRANSFER_POLICY_TYPE, policy.bcs.bcsBytes, 'base64');
+			const parsed = bcs.de(TRANSFER_POLICY_TYPE, policy.bcs.bcsBytes, 'base64');
 
 			return {
 				id: policy?.objectId,
@@ -51,3 +60,74 @@ export async function queryTransferPolicy(
 			} as TransferPolicy;
 		});
 }
+
+/**
+ * A function to fetch all the user's kiosk Caps
+ * And a list of the kiosk address ids.
+ * Returns a list of `kioskOwnerCapIds` and `kioskIds`.
+ * Extra options allow pagination.
+ * @returns TransferPolicyCap Object ID | undefined if not found.
+ */
+export async function queryTransferPolicyCapsByType(
+	client: SuiClient,
+	address: string,
+	type: string,
+): Promise<TransferPolicyCap[]> {
+	if (!isValidSuiAddress(address)) return [];
+
+	const filter = {
+		MatchAll: [
+			{
+				StructType: `${TRANSFER_POLICY_CAP_TYPE}<${type}>`,
+			},
+		],
+	};
+
+	// fetch owned kiosk caps, paginated.
+	const data = await getAllOwnedObjects({
+		client,
+		filter,
+		owner: address,
+	});
+
+	return data
+		.map((item) => parseTransferPolicyCapObject(item))
+		.filter((item) => !!item) as TransferPolicyCap[];
+}
+
+/**
+ * A function to fetch all the user's kiosk Caps
+ * And a list of the kiosk address ids.
+ * Returns a list of `kioskOwnerCapIds` and `kioskIds`.
+ * Extra options allow pagination.
+ * @returns TransferPolicyCap Object ID | undefined if not found.
+ */
+export async function queryOwnedTransferPolicies(
+	client: SuiClient,
+	address: string,
+): Promise<TransferPolicyCap[] | undefined> {
+	if (!isValidSuiAddress(address)) return;
+
+	const filter = {
+		MatchAll: [
+			{
+				MoveModule: {
+					module: 'transfer_policy',
+					package: '0x2',
+				},
+			},
+		],
+	};
+
+	// fetch all owned kiosk caps, paginated.
+	const data = await getAllOwnedObjects({ client, owner: address, filter });
+
+	const policies: TransferPolicyCap[] = [];
+
+	for (const item of data) {
+		const data = parseTransferPolicyCapObject(item);
+		if (data) policies.push(data);
+	}
+
+	return policies;
+}

package/src/tx/kiosk.ts

@@ -1,27 +1,23 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { TransactionBlock, TransactionArgument } from '@mysten/sui.js/transactions';
-
-import { getTypeWithoutPackageAddress, objArg } from '../utils';
-import { confirmRequest, resolveKioskLockRule, resolveRoyaltyRule } from './transfer-policy';
+import { bcs } from '@mysten/sui.js/bcs';
 import {
-	KIOSK_LOCK_RULE,
-	KIOSK_MODULE,
-	KIOSK_TYPE,
-	ObjectArgument,
-	PurchaseAndResolvePoliciesResponse,
-	PurchaseOptionalParams,
-	ROYALTY_RULE,
-	RulesEnvironmentParam,
-	TransferPolicy,
-} from '../types';
+	TransactionArgument,
+	TransactionBlock,
+	TransactionObjectArgument,
+} from '@mysten/sui.js/transactions';
+
+import { KIOSK_MODULE, KIOSK_TYPE, ObjectArgument } from '../types';
+import { objArg } from '../utils';
 
 /**
  * Create a new shared Kiosk and returns the [kiosk, kioskOwnerCap] tuple.
  */
-export function createKiosk(tx: TransactionBlock): [TransactionArgument, TransactionArgument] {
-	let [kiosk, kioskOwnerCap] = tx.moveCall({
+export function createKiosk(
+	tx: TransactionBlock,
+): [TransactionObjectArgument, TransactionObjectArgument] {
+	const [kiosk, kioskOwnerCap] = tx.moveCall({
 		target: `${KIOSK_MODULE}::new`,
 	});
 
@@ -32,18 +28,21 @@ export function createKiosk(tx: TransactionBlock): [TransactionArgument, Transac
  * Calls the `kiosk::new()` function and shares the kiosk.
  * Returns the `kioskOwnerCap` object.
  */
-export function createKioskAndShare(tx: TransactionBlock): TransactionArgument {
-	let [kiosk, kioskOwnerCap] = tx.moveCall({
-		target: `${KIOSK_MODULE}::new`,
-	});
+export function createKioskAndShare(tx: TransactionBlock): TransactionObjectArgument {
+	const [kiosk, kioskOwnerCap] = createKiosk(tx);
+	shareKiosk(tx, kiosk);
+	return kioskOwnerCap;
+}
 
+/**
+ * Converts Transfer Policy to a shared object.
+ */
+export function shareKiosk(tx: TransactionBlock, kiosk: TransactionArgument) {
 	tx.moveCall({
 		target: `0x2::transfer::public_share_object`,
 		typeArguments: [KIOSK_TYPE],
 		arguments: [kiosk],
 	});
-
-	return kioskOwnerCap;
 }
 
 /**
@@ -97,11 +96,11 @@ export function take(
 	kiosk: ObjectArgument,
 	kioskCap: ObjectArgument,
 	itemId: string,
-): TransactionArgument {
-	let [item] = tx.moveCall({
+): TransactionObjectArgument {
+	const [item] = tx.moveCall({
 		target: `${KIOSK_MODULE}::take`,
 		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
+		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure.address(itemId)],
 	});
 
 	return item;
@@ -125,8 +124,8 @@ export function list(
 		arguments: [
 			objArg(tx, kiosk),
 			objArg(tx, kioskCap),
-			tx.pure(itemId, 'address'),
-			tx.pure(price, 'u64'),
+			tx.pure.address(itemId),
+			tx.pure.u64(price),
 		],
 	});
 }
@@ -145,7 +144,7 @@ export function delist(
 	tx.moveCall({
 		target: `${KIOSK_MODULE}::delist`,
 		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
+		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure.address(itemId)],
 	});
 }
 
@@ -164,7 +163,7 @@ export function placeAndList(
 	tx.moveCall({
 		target: `${KIOSK_MODULE}::place_and_list`,
 		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), objArg(tx, item), tx.pure(price, 'u64')],
+		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), objArg(tx, item), tx.pure.u64(price)],
 	});
 }
 
@@ -178,11 +177,11 @@ export function purchase(
 	kiosk: ObjectArgument,
 	itemId: string,
 	payment: ObjectArgument,
-): [TransactionArgument, TransactionArgument] {
-	let [item, transferRequest] = tx.moveCall({
+): [TransactionObjectArgument, TransactionObjectArgument] {
+	const [item, transferRequest] = tx.moveCall({
 		target: `${KIOSK_MODULE}::purchase`,
 		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), tx.pure(itemId, 'address'), objArg(tx, payment)],
+		arguments: [objArg(tx, kiosk), tx.pure.address(itemId), objArg(tx, payment)],
 	});
 
 	return [item, transferRequest];
@@ -196,19 +195,11 @@ export function withdrawFromKiosk(
 	tx: TransactionBlock,
 	kiosk: ObjectArgument,
 	kioskCap: ObjectArgument,
-	amount: string | bigint | null,
-): TransactionArgument {
-	let amountArg =
-		amount !== null
-			? tx.pure(
-					{
-						Some: amount,
-					},
-					'Option<u64>',
-			  )
-			: tx.pure({ None: true }, 'Option<u64>');
+	amount?: string | bigint | number,
+): TransactionObjectArgument {
+	const amountArg = bcs.option(bcs.u64()).serialize(amount);
 
-	let [coin] = tx.moveCall({
+	const [coin] = tx.moveCall({
 		target: `${KIOSK_MODULE}::withdraw`,
 		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), amountArg],
 	});
@@ -216,46 +207,6 @@ export function withdrawFromKiosk(
 	return coin;
 }
 
-/**
- * Call the `kiosk::borrow<T>(Kiosk, KioskOwnerCap, ID): &T` function.
- * Immutably borrow an item from the Kiosk.
- */
-export function borrow(
-	tx: TransactionBlock,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	itemId: string,
-): TransactionArgument {
-	let [item] = tx.moveCall({
-		target: `${KIOSK_MODULE}::borrow`,
-		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
-	});
-
-	return item;
-}
-
-/**
- * Call the `kiosk::borrow_mut<T>(Kiosk, KioskOwnerCap, ID): &mut T` function.
- * Mutably borrow an item from the Kiosk.
- */
-export function borrowMut(
-	tx: TransactionBlock,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	itemId: string,
-): TransactionArgument {
-	let [item] = tx.moveCall({
-		target: `${KIOSK_MODULE}::borrow_mut`,
-		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
-	});
-
-	return item;
-}
-
 /**
  * Call the `kiosk::borrow_value<T>(Kiosk, KioskOwnerCap, ID): T` function.
  * Immutably borrow an item from the Kiosk and return it in the end.
@@ -269,10 +220,10 @@ export function borrowValue(
 	kioskCap: ObjectArgument,
 	itemId: string,
 ): [TransactionArgument, TransactionArgument] {
-	let [item, promise] = tx.moveCall({
+	const [item, promise] = tx.moveCall({
 		target: `${KIOSK_MODULE}::borrow_val`,
 		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
+		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure.address(itemId)],
 	});
 
 	return [item, promise];
@@ -295,75 +246,3 @@ export function returnValue(
 		arguments: [objArg(tx, kiosk), item, promise],
 	});
 }
-
-/**
- * Completes the full purchase flow that includes:
- * 1. Purchasing the item.
- * 2. Resolving all the transfer policies (if any).
- * 3. Returns the item and whether the user can transfer it or not.
- *
- * If the item can be transferred, there's an extra transaction required by the user
- * to transfer it to an address or place it in their kiosk.
- */
-export function purchaseAndResolvePolicies(
-	tx: TransactionBlock,
-	itemType: string,
-	price: string,
-	kiosk: ObjectArgument,
-	itemId: string,
-	policy: TransferPolicy,
-	environment: RulesEnvironmentParam,
-	extraParams?: PurchaseOptionalParams,
-): PurchaseAndResolvePoliciesResponse {
-	// if we don't pass the listing or the listing doens't have a price, return.
-	if (price === undefined || typeof price !== 'string')
-		throw new Error(`Price of the listing is not supplied.`);
-
-	// Split the coin for the amount of the listing.
-	const coin = tx.splitCoins(tx.gas, [tx.pure(price, 'u64')]);
-
-	// initialize the purchase `kiosk::purchase`
-	const [purchasedItem, transferRequest] = purchase(tx, itemType, kiosk, itemId, coin);
-
-	// Start resolving rules.
-	// Right now we support `kiosk_lock_rule` and `royalty_rule`.
-	// They can also be supplied in parallel (supports combination).
-	let hasKioskLockRule = false;
-
-	for (let rule of policy.rules) {
-		const ruleWithoutAddr = getTypeWithoutPackageAddress(rule);
-
-		switch (ruleWithoutAddr) {
-			case ROYALTY_RULE:
-				resolveRoyaltyRule(tx, itemType, price, policy.id, transferRequest, environment);
-				break;
-			case KIOSK_LOCK_RULE:
-				if (!extraParams?.ownedKiosk || !extraParams?.ownedKioskCap)
-					throw new Error(
-						`This item type ${itemType} has a 'kiosk_lock_rule', but function call is missing user's kiosk and kioskCap params`,
-					);
-				hasKioskLockRule = true;
-				resolveKioskLockRule(
-					tx,
-					itemType,
-					purchasedItem,
-					extraParams.ownedKiosk,
-					extraParams.ownedKioskCap,
-					policy.id,
-					transferRequest,
-					environment,
-				);
-				break;
-			default:
-				break;
-		}
-	}
-
-	// confirm the Transfer Policy request.
-	confirmRequest(tx, itemType, policy.id, transferRequest);
-
-	return {
-		item: purchasedItem,
-		canTransfer: !hasKioskLockRule,
-	};
-}

package/src/tx/personal-kiosk.ts

@@ -0,0 +1,35 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionBlock, TransactionObjectArgument } from '@mysten/sui.js/transactions';
+
+import { ObjectArgument } from '../types';
+import { objArg } from '../utils';
+
+export function convertToPersonalTx(
+	tx: TransactionBlock,
+	kiosk: ObjectArgument,
+	kioskOwnerCap: ObjectArgument,
+	packageId: string,
+): TransactionObjectArgument {
+	const personalKioskCap = tx.moveCall({
+		target: `${packageId}::personal_kiosk::new`,
+		arguments: [objArg(tx, kiosk), objArg(tx, kioskOwnerCap)],
+	});
+
+	return personalKioskCap;
+}
+
+/**
+ * Transfers the personal kiosk Cap to the sender.
+ */
+export function transferPersonalCapTx(
+	tx: TransactionBlock,
+	personalKioskCap: TransactionObjectArgument,
+	packageId: string,
+) {
+	tx.moveCall({
+		target: `${packageId}::personal_kiosk::transfer_to_sender`,
+		arguments: [personalKioskCap],
+	});
+}

package/src/tx/rules/attach.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { type TransactionBlock } from '@mysten/sui.js/transactions';
+
+import { type ObjectArgument } from '../../types';
+import { objArg } from '../../utils';
+
+export function attachKioskLockRuleTx(
+	tx: TransactionBlock,
+	type: string,
+	policy: ObjectArgument,
+	policyCap: ObjectArgument,
+	packageId: string,
+) {
+	tx.moveCall({
+		target: `${packageId}::kiosk_lock_rule::add`,
+		typeArguments: [type],
+		arguments: [objArg(tx, policy), objArg(tx, policyCap)],
+	});
+}
+
+export function attachRoyaltyRuleTx(
+	tx: TransactionBlock,
+	type: string,
+	policy: ObjectArgument,
+	policyCap: ObjectArgument,
+	percentageBps: number | string, // this is in basis points.
+	minAmount: number | string,
+	packageId: string,
+) {
+	if (Number(percentageBps) < 0 || Number(percentageBps) > 10_000)
+		throw new Error('Invalid basis point percentage. Use a value between [0,10000].');
+
+	tx.moveCall({
+		target: `${packageId}::royalty_rule::add`,
+		typeArguments: [type],
+		arguments: [
+			objArg(tx, policy),
+			objArg(tx, policyCap),
+			tx.pure.u16(Number(percentageBps)),
+			tx.pure.u64(minAmount),
+		],
+	});
+}
+
+export function attachPersonalKioskRuleTx(
+	tx: TransactionBlock,
+	type: string,
+	policy: ObjectArgument,
+	policyCap: ObjectArgument,
+	packageId: string,
+) {
+	tx.moveCall({
+		target: `${packageId}::personal_kiosk_rule::add`,
+		typeArguments: [type],
+		arguments: [objArg(tx, policy), objArg(tx, policyCap)],
+	});
+}
+
+export function attachFloorPriceRuleTx(
+	tx: TransactionBlock,
+	type: string,
+	policy: ObjectArgument,
+	policyCap: ObjectArgument,
+	minPrice: string | bigint,
+	packageId: string,
+) {
+	tx.moveCall({
+		target: `${packageId}::floor_price_rule::add`,
+		typeArguments: [type],
+		arguments: [objArg(tx, policy), objArg(tx, policyCap), tx.pure.u64(minPrice)],
+	});
+}

package/src/tx/rules/resolve.ts

@@ -0,0 +1,87 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { type RuleResolvingParams } from '../../types';
+import { objArg } from '../../utils';
+import { lock } from '../kiosk';
+
+/**
+ * A helper to resolve the royalty rule.
+ */
+export function resolveRoyaltyRule(params: RuleResolvingParams) {
+	const { transactionBlock: txb, itemType, price, packageId, transferRequest, policyId } = params;
+
+	const policyObj = objArg(txb, policyId);
+
+	// calculates the amount
+	const [amount] = txb.moveCall({
+		target: `${packageId}::royalty_rule::fee_amount`,
+		typeArguments: [itemType],
+		arguments: [policyObj, objArg(txb, price ?? '')],
+	});
+
+	// splits the coin.
+	const feeCoin = txb.splitCoins(txb.gas, [amount]);
+
+	// pays the policy
+	txb.moveCall({
+		target: `${packageId}::royalty_rule::pay`,
+		typeArguments: [itemType],
+		arguments: [policyObj, transferRequest, feeCoin],
+	});
+}
+
+export function resolveKioskLockRule(params: RuleResolvingParams) {
+	const {
+		transactionBlock: txb,
+		packageId,
+		itemType,
+		kiosk,
+		kioskCap,
+		policyId,
+		purchasedItem,
+		transferRequest,
+	} = params;
+
+	if (!kiosk || !kioskCap) throw new Error('Missing Owned Kiosk or Owned Kiosk Cap');
+
+	lock(txb, itemType, kiosk, kioskCap, policyId, purchasedItem);
+
+	// proves that the item is locked in the kiosk to the TP.
+	txb.moveCall({
+		target: `${packageId}::kiosk_lock_rule::prove`,
+		typeArguments: [itemType],
+		arguments: [transferRequest, objArg(txb, kiosk)],
+	});
+}
+
+/**
+ * A helper to resolve the personalKioskRule.
+ * @param params
+ */
+export function resolvePersonalKioskRule(params: RuleResolvingParams) {
+	const { transactionBlock: txb, packageId, itemType, kiosk, transferRequest } = params;
+
+	if (!kiosk) throw new Error('Missing owned Kiosk.');
+
+	// proves that the destination kiosk is personal.
+	txb.moveCall({
+		target: `${packageId}::personal_kiosk_rule::prove`,
+		typeArguments: [itemType],
+		arguments: [objArg(txb, kiosk), transferRequest],
+	});
+}
+
+/**
+ * Resolves the floor price rule.
+ */
+export function resolveFloorPriceRule(params: RuleResolvingParams) {
+	const { transactionBlock: txb, packageId, itemType, policyId, transferRequest } = params;
+
+	// proves that the destination kiosk is personal
+	txb.moveCall({
+		target: `${packageId}::floor_price_rule::prove`,
+		typeArguments: [itemType],
+		arguments: [objArg(txb, policyId), transferRequest],
+	});
+}