@mysten/kiosk 0.14.6 → 1.0.1

package/src/query/kiosk.ts

@@ -1,15 +1,11 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type {
-	PaginatedObjectsResponse,
-	PaginationArguments,
-	SuiClient,
-	SuiObjectData,
-	SuiObjectResponse,
-} from '@mysten/sui/client';
+import type { PaginationArguments } from '@mysten/sui/jsonRpc';
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
 import { isValidSuiAddress } from '@mysten/sui/utils';
 
+import { Extension, ExtensionKey } from '../contracts/0x2/kiosk_extension.js';
 import type {
 	FetchKioskOptions,
 	KioskExtension,
@@ -27,9 +23,10 @@ import {
 	getAllObjects,
 	getKioskObject,
 } from '../utils.js';
+import { PersonalKioskCap } from '../contracts/kiosk/personal_kiosk.js';
 
 export async function fetchKiosk(
-	client: SuiClient,
+	client: ClientWithCoreApi,
 	kioskId: string,
 	pagination: PaginationArguments<string>,
 	options: FetchKioskOptions,
@@ -51,14 +48,8 @@ export async function fetchKiosk(
 	// For listings we usually seek the DF value (price) / exclusivity.
 	const [kiosk, listingObjects, items] = await Promise.all([
 		options.withKioskFields ? getKioskObject(client, kioskId) : Promise.resolve(undefined),
-		options.withListingPrices
-			? getAllObjects(client, kioskData.listingIds, {
-					showContent: true,
-				})
-			: Promise.resolve([]),
-		options.withObjects
-			? getAllObjects(client, kioskData.itemIds, options.objectOptions || { showDisplay: true })
-			: Promise.resolve([]),
+		options.withListingPrices ? getAllObjects(client, kioskData.listingIds) : Promise.resolve([]),
+		options.withObjects ? getAllObjects(client, kioskData.itemIds) : Promise.resolve([]),
 	]);
 
 	if (options.withKioskFields) kioskData.kiosk = kiosk;
@@ -68,10 +59,7 @@ export async function fetchKiosk(
 	attachLockedItems(kioskData, lockedItemIds);
 
 	// Attach the objects for the queried items.
-	attachObjects(
-		kioskData,
-		items.filter((x) => !!x.data).map((x) => x.data!),
-	);
+	attachObjects(kioskData, items);
 
 	return {
 		data: kioskData,
@@ -91,7 +79,7 @@ const DEFAULT_PAGE_SIZE = 50;
 const PERSON_KIOSK_CURSOR = 'personal';
 const OWNED_KIOSKS_CURSOR = 'owned';
 export async function getOwnedKiosks(
-	client: SuiClient,
+	client: ClientWithCoreApi,
 	address: string,
 	options?: {
 		pagination?: PaginationArguments<string>;
@@ -115,19 +103,36 @@ export async function getOwnedKiosks(
 	];
 
 	if (options?.personalKioskType && cursorType === PERSON_KIOSK_CURSOR) {
+		const personalResult = await client.core.listOwnedObjects({
+			owner: address,
+			type: options.personalKioskType,
+			cursor,
+			limit,
+			include: {
+				content: true,
+			},
+		});
+
+		const personalKioskData = personalResult.objects
+			.filter((obj) => !(obj instanceof Error))
+			.map((obj) => {
+				return { obj, kioskId: PersonalKioskCap.parse(obj.content).cap?.for };
+			})
+			.filter(
+				(
+					item,
+				): item is {
+					obj: SuiClientTypes.Object<{ content: true }>;
+					kioskId: string;
+				} => item.kioskId !== undefined,
+			);
+
 		const personalKioskResponse = formatOwnedKioskResponse(
-			await client.getOwnedObjects({
-				owner: address,
-				filter: {
-					StructType: options.personalKioskType,
-				},
-				options: {
-					showContent: true,
-					showType: true,
-				},
-				cursor,
-				limit,
-			}),
+			{
+				data: personalKioskData,
+				hasNextPage: personalResult.hasNextPage,
+				nextCursor: personalResult.cursor,
+			},
 			PERSON_KIOSK_CURSOR,
 		);
 
@@ -148,18 +153,38 @@ export async function getOwnedKiosks(
 			};
 		}
 
+		const ownedResult = await client.core.listOwnedObjects({
+			owner: address,
+			type: KIOSK_OWNER_CAP,
+			cursor: null,
+			limit: remainingLimit,
+			include: {
+				content: true,
+			},
+		});
+
+		const { KioskOwnerCap: KioskOwnerCapParser } = await import('../contracts/0x2/kiosk.js');
+
+		const ownedKioskData = ownedResult.objects
+			.filter((obj) => !(obj instanceof Error))
+			.map((obj) => {
+				return { obj, kioskId: KioskOwnerCapParser.parse(obj.content).for };
+			})
+			.filter(
+				(
+					item,
+				): item is {
+					obj: SuiClientTypes.Object<{ content: true }>;
+					kioskId: string;
+				} => item.kioskId !== undefined,
+			);
+
 		const ownedKiosksResponse = formatOwnedKioskResponse(
-			await client.getOwnedObjects({
-				owner: address,
-				filter: {
-					StructType: KIOSK_OWNER_CAP,
-				},
-				options: {
-					showContent: true,
-					showType: true,
-				},
-				limit: remainingLimit,
-			}),
+			{
+				data: ownedKioskData,
+				hasNextPage: ownedResult.hasNextPage,
+				nextCursor: ownedResult.cursor,
+			},
 			OWNED_KIOSKS_CURSOR,
 		);
 
@@ -174,91 +199,94 @@ export async function getOwnedKiosks(
 		};
 	}
 
+	const result = await client.core.listOwnedObjects({
+		owner: address,
+		type: KIOSK_OWNER_CAP,
+		cursor: cursor || null,
+		limit,
+		include: {
+			content: true,
+		},
+	});
+
+	const { KioskOwnerCap: KioskOwnerCapParser } = await import('../contracts/0x2/kiosk.js');
+
+	const ownedKioskData = result.objects
+		.filter((obj) => !(obj instanceof Error))
+		.map((obj) => {
+			return { obj, kioskId: KioskOwnerCapParser.parse(obj.content).for };
+		})
+		.filter(
+			(
+				item,
+			): item is {
+				obj: SuiClientTypes.Object<{ content: true }>;
+				kioskId: string;
+			} => item.kioskId !== undefined,
+		);
+
 	return formatOwnedKioskResponse(
-		await client.getOwnedObjects({
-			owner: address,
-			filter: {
-				StructType: KIOSK_OWNER_CAP,
-			},
-			options: {
-				showContent: true,
-				showType: true,
-			},
-			// cursor might be an empty string if the number of personal kiosks was a multiple of the limit.
-			cursor: cursor ? cursor : null,
-			limit,
-		}),
+		{
+			data: ownedKioskData,
+			hasNextPage: result.hasNextPage,
+			nextCursor: result.cursor,
+		},
 		OWNED_KIOSKS_CURSOR,
 	);
 }
 
 function formatOwnedKioskResponse(
-	response: PaginatedObjectsResponse,
+	response: {
+		data: {
+			obj: SuiClientTypes.Object<{ content: true }>;
+			kioskId: string;
+		}[];
+		hasNextPage: boolean;
+		nextCursor: string | null;
+	},
 	cursorType: string,
 ): OwnedKiosks {
 	const { data, hasNextPage, nextCursor } = response;
-	// get kioskIds from the OwnerCaps.
-	const kioskIdList = data?.map((x: SuiObjectResponse) => {
-		const fields =
-			x.data?.content?.dataType === 'moveObject'
-				? (x.data.content.fields as unknown as
-						| {
-								cap: { fields: { for: string } };
-								for?: never;
-						  }
-						| {
-								cap?: never;
-								for: string;
-						  })
-				: null;
-		return fields?.cap ? fields?.cap?.fields?.for : (fields?.for as string);
-	});
-
-	// clean up data that might have an error in them.
-	// only return valid objects.
-	const filteredData = data.filter((x) => 'data' in x).map((x) => x.data) as SuiObjectData[];
 
 	return {
 		nextCursor: nextCursor ? `${cursorType}:${nextCursor}` : nextCursor,
 		hasNextPage,
-		kioskOwnerCaps: filteredData.map((x, idx) => ({
-			isPersonal: x.type !== KIOSK_OWNER_CAP,
-			digest: x.digest,
-			version: x.version,
-			objectId: x.objectId,
-			kioskId: kioskIdList[idx],
-		})),
-		kioskIds: kioskIdList,
+		kioskOwnerCaps: data.map((item) => {
+			const isPersonal = item.obj.type?.includes('PersonalKioskCap') || false;
+			return {
+				isPersonal,
+				digest: item.obj.digest,
+				version: item.obj.version,
+				objectId: item.obj.objectId,
+				kioskId: item.kioskId,
+			};
+		}),
+		kioskIds: data.map((item) => item.kioskId),
 	};
 }
 
 // Get a kiosk extension data for a given kioskId and extensionType.
 export async function fetchKioskExtension(
-	client: SuiClient,
+	client: ClientWithCoreApi,
 	kioskId: string,
 	extensionType: string,
 ): Promise<KioskExtension | null> {
-	const extension = await client.getDynamicFieldObject({
+	const { dynamicField } = await client.core.getDynamicField({
 		parentId: kioskId,
 		name: {
 			type: `0x2::kiosk_extension::ExtensionKey<${extensionType}>`,
-			value: {
-				dummy_field: false,
-			},
+			bcs: ExtensionKey.serialize({ dummy_field: false }).toBytes(),
 		},
 	});
 
-	if (!extension.data) return null;
-
-	const fields = (extension?.data?.content as { fields: { [k: string]: any } })?.fields?.value
-		?.fields;
+	const extension = Extension.parse(dynamicField.value.bcs);
 
 	return {
-		objectId: extension.data.objectId,
+		objectId: dynamicField.fieldId,
 		type: extensionType,
-		isEnabled: fields?.is_enabled,
-		permissions: fields?.permissions,
-		storageId: fields?.storage?.fields?.id?.id,
-		storageSize: fields?.storage?.fields?.size,
+		isEnabled: extension.is_enabled,
+		permissions: extension.permissions.toString(),
+		storageId: extension.storage.id,
+		storageSize: Number(extension.storage.size),
 	};
 }

package/src/query/transfer-policy.ts

@@ -1,133 +1,167 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { SuiClient } from '@mysten/sui/client';
-import { fromBase64, isValidSuiAddress } from '@mysten/sui/utils';
+import { isValidSuiAddress } from '@mysten/sui/utils';
+import type { ClientWithCoreApi } from '@mysten/sui/client';
 
-import '../bcs.js';
-
-import { TransferPolicyType } from '../bcs.js';
+import {
+	TransferPolicyCap as TransferPolicyCapStruct,
+	TransferPolicy as TransferPolicyStruct,
+} from '../contracts/0x2/transfer_policy.js';
 import type { TransferPolicy, TransferPolicyCap } from '../types/index.js';
 import {
 	TRANSFER_POLICY_CAP_TYPE,
 	TRANSFER_POLICY_CREATED_EVENT,
 	TRANSFER_POLICY_TYPE,
 } from '../types/index.js';
-import { getAllOwnedObjects, parseTransferPolicyCapObject } from '../utils.js';
+import { queryEvents } from './client-utils.js';
 
 /**
- * Searches the `TransferPolicy`-s for the given type. The seach is performed via
+ * Searches the `TransferPolicy`-s for the given type. The search is performed via
  * the `TransferPolicyCreated` event. The policy can either be owned or shared,
  * and the caller needs to filter the results accordingly (ie single owner can not
  * be accessed by anyone but the owner).
  *
- * @param provider
- * @param type
+ * This method requires event querying support (JSON-RPC or GraphQL clients).
+ * gRPC clients do not support event querying and will throw an error.
+ *
+ * @param client - The Sui client (must support event querying)
+ * @param type - The type of the asset (e.g., "0x123::nft::NFT")
+ * @throws Error if the client doesn't support event querying
  */
 export async function queryTransferPolicy(
-	client: SuiClient,
+	client: ClientWithCoreApi,
 	type: string,
 ): Promise<TransferPolicy[]> {
-	// console.log('event type: %s', `${TRANSFER_POLICY_CREATED_EVENT}<${type}>`);
-	const { data } = await client.queryEvents({
-		query: {
-			MoveEventType: `${TRANSFER_POLICY_CREATED_EVENT}<${type}>`,
-		},
-	});
+	const data = await queryEvents(client, `${TRANSFER_POLICY_CREATED_EVENT}<${type}>`);
+
+	const search = data.map((event) => event.json as { id: string });
 
-	const search = data.map((event) => event.parsedJson as { id: string });
-	const policies = await client.multiGetObjects({
-		ids: search.map((policy) => policy.id),
-		options: { showBcs: true, showOwner: true },
+	const { objects } = await client.core.getObjects({
+		objectIds: search.map((policy: { id: string }) => policy.id),
+		include: { content: true },
 	});
 
-	return policies
-		.filter((policy) => !!policy && 'data' in policy)
-		.map(({ data: policy }) => {
-			// should never happen; policies are objects and fetched via an event.
-			// policies are filtered for null and undefined above.
-			if (!policy || !policy.bcs || !('bcsBytes' in policy.bcs)) {
-				throw new Error(`Invalid policy: ${policy?.objectId}, expected object, got package`);
+	return objects
+		.filter((obj) => !(obj instanceof Error) && obj.content)
+		.map((obj) => {
+			if (obj instanceof Error) {
+				throw obj;
 			}
 
-			const parsed = TransferPolicyType.parse(fromBase64(policy.bcs.bcsBytes));
+			if (!obj.content) {
+				throw new Error(`Invalid policy: ${obj.objectId}, expected object with content`);
+			}
+
+			const parsed = TransferPolicyStruct.parse(obj.content);
 
 			return {
-				id: policy?.objectId,
+				id: obj.objectId,
 				type: `${TRANSFER_POLICY_TYPE}<${type}>`,
-				owner: policy?.owner!,
-				rules: parsed.rules,
-				balance: parsed.balance,
+				owner: obj.owner,
+				rules: parsed.rules.contents.map((rule) => rule.name),
+				balance: parsed.balance.value.toString(),
 			} 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.
+ * Fetches all TransferPolicyCap objects owned by an address for a specific type.
+ *
+ * @param client - The Sui client
+ * @param address - The owner address
+ * @param type - The type of the asset
+ * @returns Array of TransferPolicyCap objects
  */
 export async function queryTransferPolicyCapsByType(
-	client: SuiClient,
+	client: ClientWithCoreApi,
 	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,
-	});
+	const policies = [];
+	let hasNextPage = true;
+	let cursor: string | null = null;
+
+	while (hasNextPage) {
+		const result: Awaited<ReturnType<typeof client.core.listOwnedObjects>> =
+			await client.core.listOwnedObjects({
+				owner: address,
+				type: `${TRANSFER_POLICY_CAP_TYPE}<${type}>`,
+				cursor,
+				limit: 50,
+				include: {
+					content: true,
+				},
+			});
+
+		for (const obj of result.objects) {
+			if (obj.content) {
+				policies.push({
+					policyId: TransferPolicyCapStruct.parse(obj.content).policy_id,
+					policyCapId: obj.objectId,
+					type,
+				});
+			}
+		}
 
-	return data
-		.map((item) => parseTransferPolicyCapObject(item))
-		.filter((item) => !!item) as TransferPolicyCap[];
+		hasNextPage = result.hasNextPage;
+		cursor = result.cursor;
+	}
+
+	return policies;
 }
 
 /**
- * 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.
+ * Fetches all TransferPolicyCap objects owned by an address (all types).
+ *
+ * Uses struct-level filtering (without type parameters) to efficiently query
+ * only TransferPolicyCap objects. This matches all generic instantiations
+ * (e.g., TransferPolicyCap<T> for any T) and is supported natively by all clients.
+ *
+ * @param client - The Sui client
+ * @param address - The owner address
+ * @returns Array of TransferPolicyCap objects or undefined if address is invalid
  */
 export async function queryOwnedTransferPolicies(
-	client: SuiClient,
+	client: ClientWithCoreApi,
 	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 });
-
+	let hasNextPage = true;
+	let cursor: string | null = null;
 	const policies: TransferPolicyCap[] = [];
 
-	for (const item of data) {
-		const data = parseTransferPolicyCapObject(item);
-		if (data) policies.push(data);
+	while (hasNextPage) {
+		const result: Awaited<ReturnType<typeof client.core.listOwnedObjects>> =
+			await client.core.listOwnedObjects({
+				owner: address,
+				type: TRANSFER_POLICY_CAP_TYPE,
+				cursor,
+				limit: 50,
+				include: {
+					content: true,
+				},
+			});
+
+		// All results are TransferPolicyCap objects, extract the type parameter
+		for (const obj of result.objects) {
+			if (obj.content) {
+				// Extract the type parameter T from "0x2::transfer_policy::TransferPolicyCap<T>"
+				const objectType = obj.type!.replace(`${TRANSFER_POLICY_CAP_TYPE}<`, '').slice(0, -1);
+
+				policies.push({
+					policyId: TransferPolicyCapStruct.parse(obj.content).policy_id,
+					policyCapId: obj.objectId,
+					type: objectType,
+				});
+			}
+		}
+
+		hasNextPage = result.hasNextPage;
+		cursor = result.cursor;
 	}
 
 	return policies;