@tradeport/sui-trading-sdk 0.5.3 → 0.5.5

package/src/helpers/kiosk/getKioskPlaceBidCoin.ts

@@ -0,0 +1,59 @@
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { type Transaction } from '@mysten/sui/transactions';
+import { splitCoins } from '../splitCoins';
+import { getKioskCollectionRoyaltyFeeAmount } from './getKioskCollectionRoyaltyFeeAmount';
+
+export async function getKioskPlaceBidCoin({
+	tx,
+	suiClient,
+	bidder,
+	nftType,
+	bidAmount,
+	marketFeePrice,
+	royaltyRulePackageId,
+	royaltyRuleModule,
+	transferPolicyId,
+}: {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	bidder: string;
+	nftType: string;
+	bidAmount: number;
+	marketFeePrice: number;
+	royaltyRulePackageId?: string;
+	royaltyRuleModule?: string;
+	transferPolicyId: string;
+}) {
+	let coin;
+
+	if (royaltyRulePackageId && royaltyRuleModule) {
+		const royaltyFeeAmount = await getKioskCollectionRoyaltyFeeAmount({
+			tx,
+			suiClient,
+			walletAddress: bidder,
+			royaltyRulePackageId,
+			royaltyRuleModule,
+			transferPolicyId,
+			price: bidAmount,
+			nftType,
+		});
+
+		const [coin1, coin2] = splitCoins({
+			tx,
+			amounts: [tx.pure.u64(bidAmount + marketFeePrice), royaltyFeeAmount],
+		});
+		coin = coin1;
+
+		if (!coin1 || !coin2) throw new Error('Coin could not be split');
+
+		tx.mergeCoins(tx.object(coin1), [tx.object(coin2)]);
+	} else {
+		const [coin1] = splitCoins({
+			tx,
+			amounts: [tx.pure.u64(bidAmount + marketFeePrice)],
+		});
+		coin = coin1;
+	}
+
+	return coin;
+}

package/src/helpers/kiosk/getNativeKioskTransferPolicies.ts

@@ -0,0 +1,29 @@
+export const getNativeKioskTransferPolicies = (transferPolicies: any) => {
+	let nativeKioskTransferPolicies = transferPolicies?.filter(
+		(policy: any) =>
+			!policy?.is_origin_byte &&
+			!policy?.is_disabled &&
+			policy?.rules?.filter(
+				(rule: any) =>
+					rule?.type?.includes('royalty_rule') ||
+					rule?.type?.includes('kiosk_lock_rule') ||
+					rule?.type?.includes('personal_kiosk_rule') ||
+					rule?.type?.includes('floor_price_rule'),
+			)?.length > 0,
+	);
+
+	if (nativeKioskTransferPolicies?.length === 0 && transferPolicies?.length > 0) {
+		nativeKioskTransferPolicies = transferPolicies?.filter(
+			(policy: any) => !policy?.is_origin_byte && !policy?.is_disabled,
+		);
+	}
+
+	return nativeKioskTransferPolicies;
+};
+
+export const knownTransferPolicyRules = [
+	'royalty_rule',
+	'kiosk_lock_rule',
+	'personal_kiosk_rule',
+	'floor_price_rule',
+];

package/src/helpers/kiosk/getNativeKioskTransferPoliciesByNftType.ts

@@ -0,0 +1,21 @@
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchTransferPoliciesByType } from '../../graphql/queries/fetchTransferPoliciesByType';
+import { normalizedNftType } from '../../utils/normalizeNftType';
+import { getNativeKioskTransferPolicies } from './getNativeKioskTransferPolicies';
+
+export const getNativeKioskTransferPoliciesByNftType = async (nftType: string) => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchTransferPoliciesByType,
+		variables: { type: normalizedNftType(nftType) },
+	});
+
+	return getNativeKioskTransferPolicies(res?.transfer_policies_by_type);
+};
+
+export const knownTransferPolicyRules = [
+	'royalty_rule',
+	'kiosk_lock_rule',
+	'personal_kiosk_rule',
+	'floor_price_rule',
+];

package/src/helpers/kiosk/getRulePackageId.ts

@@ -0,0 +1,59 @@
+import { getNormalizedRuleType, type KioskClient } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { addHexPrefix } from '../../utils/addHexPrefix';
+import { normalizedNftType } from '../../utils/normalizeNftType';
+import { getTransferPolicyRuleNamesFromSuiObject } from '../getTransferPolicyRuleNamesFromSuiObject';
+import { getNativeKioskTransferPolicies } from './getNativeKioskTransferPolicies';
+import { upgradeKioskRulesPackageId } from './upgradeKioskRulesPackageId';
+
+type RuleType = 'kiosk_royalty_rule' | 'royalty_rule' | 'personal_kiosk_rule' | 'kiosk_lock_rule';
+
+export const getRulePackageId = async ({
+	transferPolicies,
+	nftType,
+	ruleType,
+	kioskClient,
+	suiClient,
+}: {
+	transferPolicies: any[];
+	suiClient: SuiGrpcClient;
+	nftType: string;
+	ruleType: RuleType;
+	kioskClient: KioskClient;
+}) => {
+	let rule: string | undefined;
+
+	if (transferPolicies.length > 0) {
+		const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+		const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
+			suiClient,
+			transferPolicyId,
+		});
+
+		rule = ruleNames.filter((ruleName) => ruleName?.split('::')?.[1] === ruleType)?.[0];
+	} else {
+		const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
+			type: normalizedNftType(nftType),
+		});
+
+		if (transferPoliciesFromMystenSdk.length > 0) {
+			rule = transferPoliciesFromMystenSdk
+				.flatMap((policy) => policy.rules)
+				.filter((rule) => rule?.split('::')?.[1] === ruleType)?.[0];
+		} else {
+			throw new Error(`No transfer policy found for ${nftType}`);
+		}
+	}
+
+	const ruleDefinition = kioskClient.rules.find(
+		(x) => getNormalizedRuleType(x.rule) === getNormalizedRuleType(rule),
+	);
+
+	let rulePackageId = ruleDefinition?.packageId;
+	if (!rulePackageId) {
+		rulePackageId = rule?.split('::')?.[0];
+	}
+
+	return upgradeKioskRulesPackageId(addHexPrefix(rulePackageId));
+};

package/src/helpers/kiosk/getTransferPoliciesToResolve.ts

@@ -0,0 +1,154 @@
+import { getNormalizedRuleType, type KioskClient } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { normalizedNftType } from '../../utils/normalizeNftType';
+import { getTransferPolicyRuleNamesFromSuiObject } from '../getTransferPolicyRuleNamesFromSuiObject';
+import {
+	getNativeKioskTransferPolicies,
+	knownTransferPolicyRules,
+} from './getNativeKioskTransferPolicies';
+import { upgradeKioskRulesPackageId } from './upgradeKioskRulesPackageId';
+
+interface RuleData {
+	rule: string;
+	rulePackageId?: string;
+	moduleName?: string;
+}
+
+export type Policy = {
+	id: string;
+	type?: string;
+	isCustom: boolean;
+	rules: RuleData[];
+};
+
+type Props = {
+	transferPolicies: any[];
+	suiClient: SuiGrpcClient;
+	kioskClient: KioskClient;
+	nftType: string;
+	customTransferPolicies?: any;
+};
+
+const originByteRuleModules = ['royalty_strategy_bps', 'transfer_allowlist'];
+
+export const getTransferPoliciesToResolve = async ({
+	transferPolicies,
+	suiClient,
+	kioskClient,
+	nftType,
+	customTransferPolicies,
+}: Props): Promise<Policy[]> => {
+	let policies: Policy[] = [];
+
+	if (transferPolicies.length > 0) {
+		const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+		if (transferPolicyId) {
+			const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
+				suiClient,
+				transferPolicyId,
+			});
+
+			policies = [
+				{
+					id: transferPolicyId,
+					rules: ruleNames?.map((rule) => ({
+						rule,
+					})),
+					isCustom: false,
+				},
+			];
+		}
+	} else {
+		const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
+			type: normalizedNftType(nftType),
+		});
+
+		if (transferPoliciesFromMystenSdk.length > 0) {
+			const policy =
+				transferPoliciesFromMystenSdk.find((policy) =>
+					policy?.rules?.some((rule) =>
+						knownTransferPolicyRules.some((ruleType) => rule?.includes(ruleType)),
+					),
+				) ?? transferPoliciesFromMystenSdk[0];
+
+			policies = [
+				{
+					id: policy.id,
+					rules: policy.rules?.map((rule) => ({
+						rule,
+					})),
+					isCustom: false,
+				},
+			];
+		} else {
+			throw new Error(
+				`Missing transfer policy of ${nftType}. No way to resolve the transfer request.`,
+			);
+		}
+	}
+
+	if (customTransferPolicies) {
+		for (const customTransferPolicy of customTransferPolicies) {
+			const customPolicy = await kioskClient.getTransferPolicies({
+				type: normalizedNftType(customTransferPolicy?.type),
+			});
+			policies = [
+				...policies,
+				{
+					id: customPolicy[0].id,
+					rules: customPolicy[0].rules?.map((rule) => ({
+						rule,
+					})),
+					isCustom: true,
+					type: customTransferPolicy?.type,
+				},
+			];
+		}
+	}
+
+	return policies.map((policy) => {
+		const kioskLockRule = policy?.rules.find((rule: RuleData) =>
+			rule?.rule?.includes('kiosk_lock_rule'),
+		);
+
+		const personalKioskRule = policy?.rules.find((rule: RuleData) =>
+			rule.rule.includes('personal_kiosk_rule'),
+		);
+
+		const otherRules = policy?.rules.filter(
+			(rule: RuleData) =>
+				!rule?.rule?.includes('kiosk_lock_rule') && !rule?.rule?.includes('personal_kiosk_rule'),
+		);
+
+		return {
+			...policy,
+			rules: [kioskLockRule, personalKioskRule, ...otherRules].filter(Boolean)?.map((ruleData) => {
+				const ruleDefinition = kioskClient.rules.find(
+					(x: any) => getNormalizedRuleType(x.rule) === getNormalizedRuleType(ruleData.rule),
+				);
+
+				let rulePackageId = ruleDefinition?.packageId;
+				if (!rulePackageId) {
+					rulePackageId = ruleData?.rule?.split('::')?.[0];
+				}
+
+				rulePackageId = upgradeKioskRulesPackageId(rulePackageId);
+
+				const moduleName = ruleData?.rule?.split('::')?.[1];
+
+				if (originByteRuleModules.includes(moduleName)) {
+					throw new Error(
+						`Using Origin Byte rule ${ruleData.rule} inside the native kiosk transaction`,
+					);
+				}
+
+				return {
+					...ruleData,
+					rulePackageId,
+					moduleName,
+				};
+			}),
+		};
+	});
+};

package/src/helpers/kiosk/isBluemoveKioskBid.ts

@@ -0,0 +1 @@
+export const isBluemoveKioskBid = (bidNonce: string): boolean => bidNonce?.startsWith('10000');

package/src/helpers/kiosk/isTradePortKioskBid.ts

@@ -0,0 +1,4 @@
+import { TRADEPORT_KIOSK_BID_NONCE_TYPE } from '../../constants';
+
+export const isTradePortKioskBid = (bidType: string): boolean =>
+	bidType === TRADEPORT_KIOSK_BID_NONCE_TYPE;

package/src/helpers/kiosk/kioskListingBcs.ts

@@ -0,0 +1,19 @@
+import { bcs } from '@mysten/sui/bcs';
+
+const PurchaseCap = bcs.struct('PurchaseCap', {
+	id: bcs.Address,
+	kiosk_id: bcs.Address,
+	item_id: bcs.Address,
+	min_price: bcs.u64(),
+});
+
+export const KioskListing = bcs.struct('KioskListing', {
+	id: bcs.Address,
+	seller: bcs.Address,
+	kiosk_id: bcs.Address,
+	nft_id: bcs.Address,
+	cap: PurchaseCap,
+	price: bcs.u64(),
+	commission: bcs.u64(),
+	beneficiary: bcs.Address,
+});

package/src/helpers/kiosk/kioskTxWrapper.ts

@@ -0,0 +1,152 @@
+import { type KioskClient, KioskTransaction } from '@mysten/kiosk';
+import { type Transaction } from '@mysten/sui/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchKiosksByOwner } from '../../graphql/queries/fetchKiosksByOwner';
+import { fetchOwnerCapByKiosk } from '../../graphql/queries/fetchOwnerCapByKiosk';
+import { fetchPersonalCapByKiosk } from '../../graphql/queries/fetchPersonalCapByKiosk';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { assertNftInSharedKiosk } from './assertNftInSharedKiosk';
+import { type SharedKioskState } from './sharedKioskState.type';
+
+type Args = {
+	tx: Transaction;
+	kioskClient: KioskClient;
+	kioskOwner: string;
+	kiosk?: any;
+	runCommands: (kioskTx: KioskTransaction) => Promise<void>;
+	shouldConvertToPersonalKiosk?: boolean;
+	shouldAssertNftInSharedKiosk?: boolean;
+	shouldAllowNftUnsharedKiosk?: boolean;
+	kioskStrategy?: 'include' | 'exclude';
+	failIfNoKiosk?: boolean;
+	sharedKioskState?: SharedKioskState;
+	shouldUseSharedKioskTx?: boolean;
+};
+
+export const kioskTxWrapper = async ({
+	tx,
+	kioskClient,
+	kioskOwner,
+	kiosk,
+	runCommands,
+	shouldConvertToPersonalKiosk,
+	shouldAssertNftInSharedKiosk,
+	shouldAllowNftUnsharedKiosk,
+	kioskStrategy,
+	failIfNoKiosk,
+	sharedKioskState,
+	shouldUseSharedKioskTx = true,
+}: Args) => {
+	if (shouldUseSharedKioskTx && sharedKioskState?.kioskTx) {
+		await runCommands(sharedKioskState.kioskTx);
+		return;
+	}
+
+	if (!kioskOwner) {
+		throw new Error('No kiosk owner provided');
+	}
+
+	let kioskTx: KioskTransaction;
+
+	let kiosks =
+		sharedKioskState?.ownerKiosks ??
+		(((
+			await gqlChainRequest({
+				chain: 'sui',
+				query: fetchKiosksByOwner,
+				variables: { ownerAddress: addLeadingZerosAfter0x(kioskOwner) },
+			})
+		).kiosks ?? []) as Array<{
+			id: string;
+			is_personal: boolean;
+			is_origin_byte: boolean;
+			is_shared: boolean;
+		}>);
+
+	if (sharedKioskState) {
+		sharedKioskState.ownerKiosks = kiosks;
+	}
+
+	if (shouldAssertNftInSharedKiosk) {
+		await assertNftInSharedKiosk({ kioskId: kiosk, walletAddress: kioskOwner, sharedKioskState });
+	}
+
+	kiosks = kiosks?.filter((k) => !k.is_origin_byte && (shouldAllowNftUnsharedKiosk || k.is_shared));
+
+	if (kiosk) {
+		let filteredKiosks = [];
+		switch (kioskStrategy ?? 'include') {
+			case 'include':
+				filteredKiosks = kiosks.filter((k) => k?.id === kiosk);
+				break;
+			case 'exclude':
+				filteredKiosks = kiosks.filter((k) => k?.id !== kiosk);
+				break;
+			default:
+				throw new Error(`Unsupported kiosk strategy ${kioskStrategy}`);
+		}
+
+		if (filteredKiosks.length > 0) {
+			kiosks = filteredKiosks;
+		} else if (failIfNoKiosk ?? false) {
+			throw new Error(`Kiosk ${kiosk} not found for account ${kioskOwner}`);
+		}
+	}
+
+	const personalKiosk = kiosks.find((k) => k.is_personal);
+
+	if (personalKiosk) {
+		// using existing personal kiosk
+		const personalKioskCapId = (
+			await gqlChainRequest({
+				chain: 'sui',
+				query: fetchPersonalCapByKiosk,
+				variables: { kioskId: personalKiosk.id },
+			})
+		).personalCap.id;
+		kioskTx = new KioskTransaction({
+			transaction: tx,
+			kioskClient,
+			cap: {
+				isPersonal: true,
+				objectId: personalKioskCapId,
+				kioskId: personalKiosk.id,
+				digest: '',
+				version: '',
+			},
+		});
+	} else if (kiosks.length > 0 && !shouldConvertToPersonalKiosk) {
+		const kioskCapId = (
+			await gqlChainRequest({
+				chain: 'sui',
+				query: fetchOwnerCapByKiosk,
+				variables: { kioskId: kiosks[0].id },
+			})
+		).ownerCap?.id;
+		kioskTx = new KioskTransaction({
+			transaction: tx,
+			kioskClient,
+			cap: {
+				isPersonal: false,
+				objectId: kioskCapId,
+				kioskId: kiosks[0].id,
+				digest: '',
+				version: '',
+			},
+		});
+	} else {
+		// creating new personal kiosk
+		kioskTx = new KioskTransaction({ transaction: tx, kioskClient });
+		kioskTx.createPersonal(true);
+	}
+
+	if (shouldUseSharedKioskTx && sharedKioskState) {
+		sharedKioskState.kioskTx = kioskTx;
+	}
+
+	await runCommands(kioskTx);
+
+	if (!sharedKioskState?.kioskTx) {
+		kioskTx.finalize();
+	}
+};

package/src/helpers/kiosk/lockNftInsideKioskIfNotLocked.ts

@@ -0,0 +1,100 @@
+import { type KioskClient, type KioskTransaction } from '@mysten/kiosk';
+import { type Transaction } from '@mysten/sui/transactions';
+import { getKioskIdFromKioskTx } from './getKioskIdFromKioskTx';
+
+export const lockNftInsideKioskIfNotLocked = async ({
+	tx,
+	kioskClient,
+	kioskTx,
+	nftTokenId,
+	nftType,
+	transferPolicyId,
+}: {
+	tx: Transaction;
+	kioskClient: KioskClient;
+	kioskTx: KioskTransaction;
+	nftTokenId: string;
+	nftType: string;
+	transferPolicyId: string;
+}) => {
+	if (
+		lockNftInsideKioskIfKioskCreatedInThisTx({ tx, kioskTx, nftTokenId, nftType, transferPolicyId })
+	) {
+		return;
+	}
+
+	const kioskId = getKioskIdFromKioskTx({ kioskTx, tx });
+	const res = await kioskClient.getKiosk({ id: kioskId });
+	const nftInKiosk = res.items.find((i) => i.objectId === nftTokenId);
+	let takeFromKiosk = true;
+
+	if (!nftInKiosk) {
+		const { object } = await (kioskClient.client as any).getObject({
+			objectId: nftTokenId,
+			include: {},
+		});
+		if (object?.owner?.$kind === 'AddressOwner') {
+			// NFT is owned by account
+			takeFromKiosk = false;
+		} else {
+			throw new Error(`NFT ${nftTokenId} is not found in kiosk ${kioskId}`);
+		}
+	}
+
+	if (!nftInKiosk?.isLocked) {
+		let takenNftId;
+
+		if (takeFromKiosk) {
+			const takenNft = kioskTx.take({
+				itemId: nftTokenId,
+				itemType: nftType,
+			});
+
+			takenNftId = (takenNft as any).value ?? takenNft;
+		}
+
+		kioskTx.lock({
+			item: takenNftId ?? nftTokenId,
+			itemType: nftType,
+			policy: transferPolicyId,
+		});
+	}
+};
+
+function lockNftInsideKioskIfKioskCreatedInThisTx({
+	tx,
+	kioskTx,
+	nftTokenId,
+	nftType,
+	transferPolicyId,
+}: {
+	tx: Transaction;
+	kioskTx: any;
+	nftTokenId: string;
+	nftType: string;
+	transferPolicyId: string;
+}) {
+	if (Array.isArray(kioskTx.kiosk.NestedResult)) {
+		const transaction = (tx as any).getData().commands[kioskTx.kiosk.NestedResult[0]] as {
+			target: string;
+		};
+		if (
+			transaction.target ===
+				'0x0000000000000000000000000000000000000000000000000000000000000002::kiosk::new' ||
+			transaction.target ===
+				'0x0000000000000000000000000000000000000000000000000000000000000002::personal_kiosk::new'
+		) {
+			// just created in this transaction block kiosk
+			kioskTx.lock({
+				item: nftTokenId,
+				itemType: nftType,
+				policy: transferPolicyId,
+			});
+			return true;
+		}
+
+		throw new Error(`Unsupported kiosk move call ${transaction.target}`);
+	}
+
+	return false;
+}