@mysten/kiosk 0.14.6 → 1.0.1

package/src/tx/kiosk.ts

@@ -1,243 +1,19 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { bcs } from '@mysten/sui/bcs';
-import type {
-	Transaction,
-	TransactionArgument,
-	TransactionObjectArgument,
-} from '@mysten/sui/transactions';
-
-import type { ObjectArgument } from '../types/index.js';
-import { KIOSK_MODULE, KIOSK_TYPE } from '../types/index.js';
-
-/**
- * Create a new shared Kiosk and returns the [kiosk, kioskOwnerCap] tuple.
- */
-export function createKiosk(
-	tx: Transaction,
-): [TransactionObjectArgument, TransactionObjectArgument] {
-	const [kiosk, kioskOwnerCap] = tx.moveCall({
-		target: `${KIOSK_MODULE}::new`,
-	});
-
-	return [kiosk, kioskOwnerCap];
-}
+import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
+import * as kiosk from '../contracts/0x2/kiosk.js';
 
 /**
  * Calls the `kiosk::new()` function and shares the kiosk.
  * Returns the `kioskOwnerCap` object.
  */
 export function createKioskAndShare(tx: Transaction): TransactionObjectArgument {
-	const [kiosk, kioskOwnerCap] = createKiosk(tx);
-	shareKiosk(tx, kiosk);
-	return kioskOwnerCap;
-}
-
-/**
- * Converts Transfer Policy to a shared object.
- */
-export function shareKiosk(tx: Transaction, kiosk: TransactionArgument) {
-	tx.moveCall({
-		target: `0x2::transfer::public_share_object`,
-		typeArguments: [KIOSK_TYPE],
-		arguments: [kiosk],
-	});
-}
-
-/**
- * Call the `kiosk::place<T>(Kiosk, KioskOwnerCap, Item)` function.
- * Place an item to the Kiosk.
- */
-export function place(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	item: ObjectArgument,
-): void {
-	tx.moveCall({
-		target: `${KIOSK_MODULE}::place`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), tx.object(kioskCap), tx.object(item)],
-	});
-}
-
-/**
- * Call the `kiosk::lock<T>(Kiosk, KioskOwnerCap, TransferPolicy, Item)`
- * function. Lock an item in the Kiosk.
- *
- * Unlike `place` this function requires a `TransferPolicy` to exist
- * and be passed in. This is done to make sure the item does not get
- * locked without an option to take it out.
- */
-export function lock(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	policy: ObjectArgument,
-	item: ObjectArgument,
-): void {
-	tx.moveCall({
-		target: `${KIOSK_MODULE}::lock`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), tx.object(kioskCap), tx.object(policy), tx.object(item)],
-	});
-}
-
-/**
- * Call the `kiosk::take<T>(Kiosk, KioskOwnerCap, ID)` function.
- * Take an item from the Kiosk.
- */
-export function take(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	itemId: string,
-): TransactionObjectArgument {
-	const [item] = tx.moveCall({
-		target: `${KIOSK_MODULE}::take`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), tx.object(kioskCap), tx.pure.id(itemId)],
-	});
-
-	return item;
-}
-
-/**
- * Call the `kiosk::list<T>(Kiosk, KioskOwnerCap, ID, u64)` function.
- * List an item for sale.
- */
-export function list(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	itemId: string,
-	price: string | bigint,
-): void {
-	tx.moveCall({
-		target: `${KIOSK_MODULE}::list`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), tx.object(kioskCap), tx.pure.id(itemId), tx.pure.u64(price)],
-	});
-}
-
-/**
- * Call the `kiosk::list<T>(Kiosk, KioskOwnerCap, ID, u64)` function.
- * List an item for sale.
- */
-export function delist(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	itemId: string,
-): void {
+	const [kioskObj, kioskOwnerCap] = tx.add(kiosk._new({}));
 	tx.moveCall({
-		target: `${KIOSK_MODULE}::delist`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), tx.object(kioskCap), tx.pure.id(itemId)],
-	});
-}
-
-/**
- * Call the `kiosk::place_and_list<T>(Kiosk, KioskOwnerCap, Item, u64)` function.
- * Place an item to the Kiosk and list it for sale.
- */
-export function placeAndList(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	item: ObjectArgument,
-	price: string | bigint,
-): void {
-	tx.moveCall({
-		target: `${KIOSK_MODULE}::place_and_list`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), tx.object(kioskCap), tx.object(item), tx.pure.u64(price)],
-	});
-}
-
-/**
- * Call the `kiosk::purchase<T>(Kiosk, ID, Coin<SUI>)` function and receive an Item and
- * a TransferRequest which needs to be dealt with (via a matching TransferPolicy).
- */
-export function purchase(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	itemId: string,
-	payment: ObjectArgument,
-): [TransactionObjectArgument, TransactionObjectArgument] {
-	const [item, transferRequest] = tx.moveCall({
-		target: `${KIOSK_MODULE}::purchase`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), tx.pure.id(itemId), tx.object(payment)],
-	});
-
-	return [item, transferRequest];
-}
-
-/**
- * Call the `kiosk::withdraw(Kiosk, KioskOwnerCap, Option<u64>)` function and receive a Coin<SUI>.
- * If the amount is null, then the entire balance will be withdrawn.
- */
-export function withdrawFromKiosk(
-	tx: Transaction,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	amount?: string | bigint | number,
-): TransactionObjectArgument {
-	const amountArg = bcs.option(bcs.u64()).serialize(amount);
-
-	const [coin] = tx.moveCall({
-		target: `${KIOSK_MODULE}::withdraw`,
-		arguments: [tx.object(kiosk), tx.object(kioskCap), amountArg],
-	});
-
-	return coin;
-}
-
-/**
- * Call the `kiosk::borrow_value<T>(Kiosk, KioskOwnerCap, ID): T` function.
- * Immutably borrow an item from the Kiosk and return it in the end.
- *
- * Requires calling `returnValue` to return the item.
- */
-export function borrowValue(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	itemId: string,
-): [TransactionArgument, TransactionArgument] {
-	const [item, promise] = tx.moveCall({
-		target: `${KIOSK_MODULE}::borrow_val`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), tx.object(kioskCap), tx.pure.id(itemId)],
-	});
-
-	return [item, promise];
-}
-
-/**
- * Call the `kiosk::return_value<T>(Kiosk, Item, Borrow)` function.
- * Return an item to the Kiosk after it was `borrowValue`-d.
- */
-export function returnValue(
-	tx: Transaction,
-	itemType: string,
-	kiosk: ObjectArgument,
-	item: TransactionArgument,
-	promise: TransactionArgument,
-): void {
-	tx.moveCall({
-		target: `${KIOSK_MODULE}::return_val`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), item, promise],
+		target: '0x2::transfer::public_share_object',
+		arguments: [kioskObj],
+		typeArguments: ['0x2::kiosk::Kiosk'],
 	});
+	return kioskOwnerCap;
 }

package/src/tx/rules/resolve.ts

@@ -1,26 +1,29 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { bcs } from '@mysten/sui/bcs';
 import type { TransactionArgument } from '@mysten/sui/transactions';
 import { Transaction } from '@mysten/sui/transactions';
+import { bcs } from '@mysten/sui/bcs';
 import { normalizeSuiAddress } from '@mysten/sui/utils';
 
 import type { RuleResolvingParams } from '../../types/index.js';
-import { lock } from '../kiosk.js';
-
+import * as kiosk from '../../contracts/0x2/kiosk.js';
+import * as royaltyRule from '../../contracts/kiosk/royalty_rule.js';
+import * as kioskLockRule from '../../contracts/kiosk/kiosk_lock_rule.js';
+import * as personalKioskRule from '../../contracts/kiosk/personal_kiosk_rule.js';
+import * as floorPriceRule from '../../contracts/kiosk/floor_price_rule.js';
 /**
  * A helper to resolve the royalty rule.
  */
 export async function resolveRoyaltyRule(params: RuleResolvingParams) {
 	const {
-		kioskClient,
 		transaction: tx,
 		itemType,
 		price,
 		packageId,
 		transferRequest,
 		policyId,
+		kioskClient,
 	} = params;
 
 	// We attempt to resolve the fee amount outside of the PTB so that the split amount is known before the transaction is sent.
@@ -29,45 +32,69 @@ export async function resolveRoyaltyRule(params: RuleResolvingParams) {
 	const feeTx = new Transaction();
 
 	// calculates the amount
-	feeTx.moveCall({
-		target: `${packageId}::royalty_rule::fee_amount`,
-		typeArguments: [itemType],
-		arguments: [feeTx.object(policyId), feeTx.pure.u64(price || '0')],
-	});
+	feeTx.add(
+		royaltyRule.feeAmount({
+			package: packageId,
+			arguments: {
+				policy: feeTx.object(policyId),
+				paid: BigInt(price || '0'),
+			},
+			typeArguments: [itemType],
+		}),
+	);
 
 	const policyObj = tx.object(policyId);
 
-	const { results } = await kioskClient.client.devInspectTransactionBlock({
-		sender: tx.getData().sender || normalizeSuiAddress('0x0'),
-		transactionBlock: feeTx,
-	});
-
 	let amount: TransactionArgument | bigint | null = null;
-	if (results) {
-		const returnedAmount = results?.[0].returnValues?.[0]?.[0];
-		if (returnedAmount) {
-			amount = BigInt(bcs.U64.parse(new Uint8Array(returnedAmount as number[])));
+
+	try {
+		feeTx.setSender(tx.getData().sender || normalizeSuiAddress('0x0'));
+		const txBytes = await feeTx.build({ client: kioskClient.client });
+
+		const result = await kioskClient.client.core.simulateTransaction({
+			transaction: txBytes,
+			include: { commandResults: true },
+		});
+
+		if (result.commandResults && result.commandResults.length > 0) {
+			const returnedAmount = result.commandResults[0]?.returnValues?.[0]?.bcs;
+			if (returnedAmount) {
+				amount = BigInt(bcs.U64.parse(returnedAmount));
+			}
 		}
+	} catch {
+		// If simulate fails, fall back to resolving within the PTB
 	}
 
 	// We were not able to calculate the amount outside of the transaction, so fall back to resolving it within the PTB
 	if (!amount) {
-		[amount] = tx.moveCall({
-			target: `${packageId}::royalty_rule::fee_amount`,
-			typeArguments: [itemType],
-			arguments: [policyObj, tx.pure.u64(price || '0')],
-		});
+		[amount] = tx.add(
+			royaltyRule.feeAmount({
+				package: packageId,
+				arguments: {
+					policy: policyObj,
+					paid: BigInt(price || '0'),
+				},
+				typeArguments: [itemType],
+			}),
+		);
 	}
 
 	// splits the coin.
 	const feeCoin = tx.splitCoins(tx.gas, [amount]);
 
 	// pays the policy
-	tx.moveCall({
-		target: `${packageId}::royalty_rule::pay`,
-		typeArguments: [itemType],
-		arguments: [policyObj, transferRequest, feeCoin],
-	});
+	tx.add(
+		royaltyRule.pay({
+			package: packageId,
+			arguments: {
+				policy: policyObj,
+				request: transferRequest,
+				payment: feeCoin,
+			},
+			typeArguments: [itemType],
+		}),
+	);
 }
 
 export function resolveKioskLockRule(params: RuleResolvingParams) {
@@ -75,23 +102,33 @@ export function resolveKioskLockRule(params: RuleResolvingParams) {
 		transaction: tx,
 		packageId,
 		itemType,
-		kiosk,
+		kiosk: kioskId,
 		kioskCap,
 		policyId,
 		purchasedItem,
 		transferRequest,
 	} = params;
 
-	if (!kiosk || !kioskCap) throw new Error('Missing Owned Kiosk or Owned Kiosk Cap');
+	if (!kioskId || !kioskCap) throw new Error('Missing Owned Kiosk or Owned Kiosk Cap');
 
-	lock(tx, itemType, kiosk, kioskCap, policyId, purchasedItem);
+	tx.add(
+		kiosk.lock({
+			arguments: [kioskId, kioskCap, policyId, purchasedItem],
+			typeArguments: [itemType],
+		}),
+	);
 
 	// proves that the item is locked in the kiosk to the TP.
-	tx.moveCall({
-		target: `${packageId}::kiosk_lock_rule::prove`,
-		typeArguments: [itemType],
-		arguments: [transferRequest, tx.object(kiosk)],
-	});
+	tx.add(
+		kioskLockRule.prove({
+			package: packageId,
+			arguments: {
+				request: transferRequest,
+				kiosk: tx.object(kioskId),
+			},
+			typeArguments: [itemType],
+		}),
+	);
 }
 
 /**
@@ -104,23 +141,35 @@ export function resolvePersonalKioskRule(params: RuleResolvingParams) {
 	if (!kiosk) throw new Error('Missing owned Kiosk.');
 
 	// proves that the destination kiosk is personal.
-	tx.moveCall({
-		target: `${packageId}::personal_kiosk_rule::prove`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), transferRequest],
-	});
+	tx.add(
+		personalKioskRule.prove({
+			package: packageId,
+			arguments: {
+				kiosk: tx.object(kiosk),
+				request: transferRequest,
+			},
+			typeArguments: [itemType],
+		}),
+	);
 }
 
 /**
- * Resolves the floor price rule.
+ * A helper to resolve the floor price rule.
+ * The floor price rule verifies that the paid amount meets the minimum price.
+ * @param params
  */
 export function resolveFloorPriceRule(params: RuleResolvingParams) {
 	const { transaction: tx, packageId, itemType, policyId, transferRequest } = params;
 
-	// proves that the destination kiosk is personal
-	tx.moveCall({
-		target: `${packageId}::floor_price_rule::prove`,
-		typeArguments: [itemType],
-		arguments: [tx.object(policyId), transferRequest],
-	});
+	// proves that the paid amount meets the floor price requirement
+	tx.add(
+		floorPriceRule.prove({
+			package: packageId,
+			arguments: {
+				policy: tx.object(policyId),
+				request: transferRequest,
+			},
+			typeArguments: [itemType],
+		}),
+	);
 }

package/src/tx/transfer-policy.ts

@@ -1,15 +1,10 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { bcs } from '@mysten/sui/bcs';
-import type {
-	Transaction,
-	TransactionArgument,
-	TransactionObjectArgument,
-} from '@mysten/sui/transactions';
+import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
 
 import type { ObjectArgument } from '../types/index.js';
-import { TRANSFER_POLICY_MODULE, TRANSFER_POLICY_TYPE } from '../types/index.js';
+import * as transferPolicy from '../contracts/0x2/transfer_policy.js';
 
 /**
  * Call the `transfer_policy::new` function to create a new transfer policy.
@@ -20,47 +15,20 @@ export function createTransferPolicy(
 	itemType: string,
 	publisher: ObjectArgument,
 ): TransactionObjectArgument {
-	const [transferPolicy, transferPolicyCap] = createTransferPolicyWithoutSharing(
-		tx,
-		itemType,
-		publisher,
+	const [policy, policyCap] = tx.add(
+		transferPolicy._new({
+			arguments: [publisher],
+			typeArguments: [itemType],
+		}),
 	);
 
-	shareTransferPolicy(tx, itemType, transferPolicy);
-
-	return transferPolicyCap;
-}
-
-/**
- * Creates a transfer Policy and returns both the Policy and the Cap.
- * Used if we want to use the policy before making it a shared object.
- */
-export function createTransferPolicyWithoutSharing(
-	tx: Transaction,
-	itemType: string,
-	publisher: ObjectArgument,
-): [TransactionObjectArgument, TransactionObjectArgument] {
-	const [transferPolicy, transferPolicyCap] = tx.moveCall({
-		target: `${TRANSFER_POLICY_MODULE}::new`,
-		typeArguments: [itemType],
-		arguments: [tx.object(publisher)],
-	});
-
-	return [transferPolicy, transferPolicyCap];
-}
-/**
- * Converts Transfer Policy to a shared object.
- */
-export function shareTransferPolicy(
-	tx: Transaction,
-	itemType: string,
-	transferPolicy: TransactionObjectArgument,
-) {
 	tx.moveCall({
-		target: `0x2::transfer::public_share_object`,
-		typeArguments: [`${TRANSFER_POLICY_TYPE}<${itemType}>`],
-		arguments: [transferPolicy],
+		target: '0x2::transfer::public_share_object',
+		arguments: [policy],
+		typeArguments: [`0x2::transfer_policy::TransferPolicy<${itemType}>`],
 	});
+
+	return policyCap;
 }
 
 /**
@@ -73,48 +41,19 @@ export function withdrawFromPolicy(
 	policyCap: ObjectArgument,
 	amount?: string | bigint | null,
 ): TransactionObjectArgument {
-	const amountArg = bcs.option(bcs.u64()).serialize(amount);
-
-	const [profits] = tx.moveCall({
-		target: `${TRANSFER_POLICY_MODULE}::withdraw`,
-		typeArguments: [itemType],
-		arguments: [tx.object(policy), tx.object(policyCap), amountArg],
-	});
+	// Convert string to bigint if needed for the generated function
+	const amountArg: bigint | null = amount
+		? typeof amount === 'string'
+			? BigInt(amount)
+			: amount
+		: null;
+
+	const [profits] = tx.add(
+		transferPolicy.withdraw({
+			arguments: [policy, policyCap, amountArg],
+			typeArguments: [itemType],
+		}),
+	);
 
 	return profits;
 }
-
-/**
- * Call the `transfer_policy::confirm_request` function to unblock the
- * transaction.
- */
-export function confirmRequest(
-	tx: Transaction,
-	itemType: string,
-	policy: ObjectArgument,
-	request: TransactionArgument,
-): void {
-	tx.moveCall({
-		target: `${TRANSFER_POLICY_MODULE}::confirm_request`,
-		typeArguments: [itemType],
-		arguments: [tx.object(policy), request],
-	});
-}
-
-/**
- * Calls the `transfer_policy::remove_rule` function to remove a Rule from the transfer policy's ruleset.
- */
-export function removeTransferPolicyRule(
-	tx: Transaction,
-	itemType: string,
-	ruleType: string,
-	configType: string,
-	policy: ObjectArgument,
-	policyCap: ObjectArgument,
-): void {
-	tx.moveCall({
-		target: `${TRANSFER_POLICY_MODULE}::remove_rule`,
-		typeArguments: [itemType, ruleType, configType],
-		arguments: [tx.object(policy), tx.object(policyCap)],
-	});
-}

package/src/types/index.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { SuiClient } from '@mysten/sui/client';
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
 import type { TransactionObjectArgument } from '@mysten/sui/transactions';
 
 import type { BaseRulePackageIds } from '../constants.js';
@@ -14,22 +14,11 @@ export * from './transfer-policy.js';
  */
 export type ObjectArgument = string | TransactionObjectArgument;
 
-/**
- * A Network selector.
- * Kiosk SDK supports mainnet & testnet.
- * Pass `custom` for any other network (devnet, localnet).
- */
-export enum Network {
-	MAINNET = 'mainnet',
-	TESTNET = 'testnet',
-	CUSTOM = 'custom',
-}
-
 /**
  * The Client Options for Both KioskClient & TransferPolicyManager.
  */
 export type KioskClientOptions = {
-	client: SuiClient;
-	network: Network;
+	client: ClientWithCoreApi;
+	network: SuiClientTypes.Network;
 	packageIds?: BaseRulePackageIds;
 };

package/src/types/kiosk.ts

@@ -1,17 +1,15 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type {
-	PaginatedObjectsResponse,
-	SuiObjectData,
-	SuiObjectDataOptions,
-} from '@mysten/sui/client';
 import type { TransactionArgument } from '@mysten/sui/transactions';
+import { SuiClientTypes } from '@mysten/sui/client';
 
 import type { ObjectArgument } from './index.js';
 
+import { SUI_FRAMEWORK_ADDRESS } from '@mysten/sui/utils';
+
 /** The Kiosk module. */
-export const KIOSK_MODULE = '0x2::kiosk';
+export const KIOSK_MODULE = `${SUI_FRAMEWORK_ADDRESS}::kiosk`;
 
 /** The Kiosk type. */
 export const KIOSK_TYPE = `${KIOSK_MODULE}::Kiosk`;
@@ -105,8 +103,8 @@ export type KioskItem = {
 	listing?: KioskListing;
 	/** The ID of the kiosk the item is placed in */
 	kioskId: string;
-	/** Optional Kiosk Data */
-	data?: SuiObjectData;
+	/** Optional Kiosk Data (core API object) */
+	data?: SuiClientTypes.Object;
 };
 
 /** The overview type returned from `getKiosk` */
@@ -149,16 +147,16 @@ export type FetchKioskOptions = {
 	withKioskFields?: boolean;
 	/** Include the listing prices. */
 	withListingPrices?: boolean;
-	/** Include the objects for the Items in the kiosk. Defaults to `display` only. */
+	/** Include the objects for the Items in the kiosk. */
 	withObjects?: boolean;
-	/** Pass the data options for the objects, when fetching, in case you want to query other details. */
-	objectOptions?: SuiObjectDataOptions;
 };
 
 export type OwnedKiosks = {
 	kioskOwnerCaps: KioskOwnerCap[];
 	kioskIds: string[];
-} & Omit<PaginatedObjectsResponse, 'data'>;
+	nextCursor: string | null;
+	hasNextPage: boolean;
+};
 
 export type KioskOwnerCap = {
 	isPersonal?: boolean;