@tradeport/sui-trading-sdk 0.0.0

package/src/graphql/queries/getCommissionByListingId.ts

@@ -0,0 +1,15 @@
+import { gqlChainRequest } from '../gqlChainRequest';
+import { fetchCommissionByNftContractId } from './fetchCommissionByListingId';
+
+export const getCommissionByNftContractId = async (nftContractId: string) => {
+	try {
+		const res = await gqlChainRequest({
+			chain: 'sui',
+			query: fetchCommissionByNftContractId,
+			variables: { nftContractId },
+		});
+		return res?.commissions?.[0];
+	} catch (err) {
+		throw new Error(`Failed to fetch commission for listing ${nftContractId}`);
+	}
+};

package/src/helpers/addOneDollarFee.ts

@@ -0,0 +1,17 @@
+import { type TransactionBlock } from '@mysten/sui.js/transactions';
+import { TRADEPORT_BENEFICIARY_ADDRESS } from '../constants';
+import { addLeadingZerosAfter0x } from '../utils/addLeadingZerosAfter0x';
+import { getSuiToUsdRate } from './getSuiToUsdRate';
+
+export const addOneDollarFee = async (txBlock: TransactionBlock) => {
+	const rate = await getSuiToUsdRate();
+
+	const companyFee = BigInt(Math.ceil(1_000_000_000 / rate));
+
+	const [microTxFee] = txBlock.splitCoins(txBlock.gas, [txBlock.pure(Number(companyFee))]);
+
+	txBlock.transferObjects(
+		[txBlock.object(microTxFee)],
+		txBlock.pure(addLeadingZerosAfter0x(TRADEPORT_BENEFICIARY_ADDRESS)),
+	);
+};

package/src/helpers/addThirdPartyTxFee.ts

@@ -0,0 +1,17 @@
+import { type TransactionBlock } from '@mysten/sui.js/transactions';
+import {
+	TRADEPORT_BENEFICIARY_ADDRESS,
+	TRADEPORT_THIRD_PARTY_FEE_DECIMAL_PERCENT,
+} from '../constants';
+import { addLeadingZerosAfter0x } from '../utils/addLeadingZerosAfter0x';
+
+export const addThirdPartyTxFee = async (txBlock: TransactionBlock, price: number) => {
+	const [microTxFee] = txBlock.splitCoins(txBlock.gas, [
+		txBlock.pure(price * TRADEPORT_THIRD_PARTY_FEE_DECIMAL_PERCENT),
+	]);
+
+	txBlock.transferObjects(
+		[txBlock.object(microTxFee)],
+		txBlock.pure(addLeadingZerosAfter0x(TRADEPORT_BENEFICIARY_ADDRESS)),
+	);
+};

package/src/helpers/destroyZeroCoin.ts

@@ -0,0 +1,14 @@
+import { type TransactionBlock, type TransactionObjectArgument } from '@mysten/sui.js/transactions';
+
+type Args = {
+	txBlock: TransactionBlock;
+	coin: string | TransactionObjectArgument;
+};
+
+export const destroyZeroCoin = ({ txBlock, coin }: Args) => {
+	txBlock.moveCall({
+		target: '0x2::coin::destroy_zero',
+		arguments: [txBlock.object(coin)],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+};

package/src/helpers/getMarketFeePrice.ts

@@ -0,0 +1,78 @@
+import {
+	BASC_ROYALTY_DECIMAL_PERCENT,
+	COLLECTION_IDS_WITH_ZERO_COMMISSION,
+	DSL_LEGACY_ROYALTY_DECIMAL_PERCENT,
+	MASC_ROYALTY_DECIMAL_PERCENT,
+	TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT,
+} from '../constants';
+
+export const getMASCMarketFeePrice = (price: number) => {
+	if (price * (MASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT) < 1) {
+		return price * (MASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT);
+	}
+
+	return parseInt(
+		(price * (MASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT))?.toFixed(0),
+		10,
+	);
+};
+
+export const getBASCMarketFeePrice = (price: number) => {
+	if (price * (BASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT) < 1) {
+		return price * (BASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT);
+	}
+
+	return parseInt(
+		(price * (BASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT))?.toFixed(0),
+		10,
+	);
+};
+
+export const getDSLLegacyMarketFeePrice = (price: number) => {
+	if (price * (DSL_LEGACY_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT) < 1) {
+		return price * (DSL_LEGACY_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT);
+	}
+
+	return parseInt(
+		(price * (DSL_LEGACY_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT))?.toFixed(
+			0,
+		),
+		10,
+	);
+};
+
+type GetMarketFeePrice = {
+	price: number;
+	collectionId: string;
+	walletId: string;
+};
+
+export const getMarketFeePrice = ({ price, collectionId, walletId }: GetMarketFeePrice) => {
+	if (collectionId === '6824e1ff-477e-4810-9ba7-8d6387b68c7d') {
+		return getBASCMarketFeePrice(price);
+	}
+
+	if (collectionId === '8568521c-73a3-4beb-b830-d1ff27a3f1ca') {
+		return getMASCMarketFeePrice(price);
+	}
+
+	if (collectionId === '307c7e7a-be3a-43a5-ae44-37f3a37d01f9') {
+		return getDSLLegacyMarketFeePrice(price);
+	}
+
+	// if (collectionId === 'c3d1ce36-6afd-4336-b619-44c745dd7569') {
+	// 	return getEggMarketFeePrice(price);
+	// }
+
+	let marketFeePrice = 0;
+
+	if (!COLLECTION_IDS_WITH_ZERO_COMMISSION?.includes(collectionId)) {
+		marketFeePrice = price * TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT;
+	}
+
+	if (marketFeePrice < 1) {
+		return marketFeePrice;
+	}
+
+	return parseInt(marketFeePrice?.toFixed(0), 10);
+};

package/src/helpers/getNftTypeFromNft.ts

@@ -0,0 +1,8 @@
+export const getNftTypeFromNft = (nft: any): string => {
+	let nftType = nft?.properties?.nft_type;
+	if (!nftType || nftType?.split('::')?.length <= 1) {
+		nftType = nft?.contract?.properties?.nft_type;
+	}
+
+	return nftType;
+};

package/src/helpers/getSharedObjects.ts

@@ -0,0 +1,113 @@
+import {
+	CRYPTOPEDIA_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	FUDDIES_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	GNOMES_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	SACABAM_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	STORKS_ORIGIN_BYTE_ALLOW_LIST,
+	SUISHI_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	SUI_ECOSYSTEM_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+} from '../constants';
+import { gqlChainRequest } from '../graphql/gqlChainRequest';
+import { fetchSharedObjectsByType } from '../graphql/queries/fetchSharedObjectsByType';
+import { addLeadingZerosAfter0x } from '../utils/addLeadingZerosAfter0x';
+
+export type SuiSharedObjects = {
+	orderbook: string;
+	collection: string;
+	royaltyStrategy: string;
+	keepsakeRoyaltyStrategy: string;
+	transferPolicy: string;
+	marketplace: string;
+	allowList: string;
+};
+
+export const getSharedObjects = async (nftType: string): Promise<SuiSharedObjects> => {
+	const nftTypeSplit = nftType?.split('::');
+	if (nftTypeSplit?.[0]) nftTypeSplit[0] = addLeadingZerosAfter0x(nftTypeSplit[0]);
+
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchSharedObjectsByType,
+		variables: { type: nftTypeSplit?.join('::') },
+	});
+
+	let allowList = res?.sharedObjects?.filter((object: any) => object?.module === 'allowlist')?.[0]
+		?.id;
+	if (!allowList) allowList = ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+	if (
+		nftType === '0x5f1fa51a6d5c52df7dfe0ff7efaab7cc769d81e51cf208a424e455575aa1ed7a::stork::Stork'
+	) {
+		allowList = STORKS_ORIGIN_BYTE_ALLOW_LIST;
+	}
+
+	if (
+		nftType === '0xf1681f601a1c021a0b4c8c8859d50917308fcbebfd19364c4e856ac670bb8496::suishi::Suishi'
+	) {
+		allowList = SUISHI_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+	}
+
+	if (
+		nftType?.includes(
+			'ac176715abe5bcdaae627c5048958bbe320a8474f524674f3278e31af3c8b86b::fuddies::Fuddies',
+		)
+	) {
+		allowList = FUDDIES_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+	}
+
+	if (
+		nftType ===
+		'0x71bd3651e47a7590e607b976a332338e2230e995fa96de430703af537086b643::cryptopedia::Cryptopedia'
+	) {
+		allowList = CRYPTOPEDIA_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+	}
+
+	if (
+		nftType === '0xe81341eba87d19f8d53ee237b3666cff6a74c9fd7a960cf5753af69bc7c6a221::gnomes::Gnome'
+	) {
+		allowList = GNOMES_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+	}
+
+	if (
+		nftType ===
+		'0x7f481ffff2b72f3f1d9b70d5ad999d8b514a6281aa29aedbb6c537bd4b0d04ad::sacabam::Sacabam'
+	) {
+		allowList = SACABAM_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+	}
+
+	if (
+		nftType ===
+		'0x5fe8e884960f6977f813d871a3d43049d72d19d4ad07819b979c06434f60af4d::mint::SuiEcosystemNFT'
+	) {
+		allowList = SUI_ECOSYSTEM_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+	}
+
+	let transferPolicy = res?.sharedObjects?.filter(
+		(object: any) => object?.module === 'transfer_policy',
+	)?.[0]?.id;
+
+	if (nftTypeSplit?.join('::')?.includes('keepsake_nft::KEEPSAKE')) {
+		transferPolicy = res?.sharedObjects?.filter(
+			(object: any) =>
+				object?.type?.includes(
+					'0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::transfer_policy::TransferPolicy',
+				),
+		)?.[0]?.id;
+	}
+
+	return {
+		orderbook: res?.sharedObjects?.filter((object: any) => object?.module === 'orderbook')?.[0]?.id,
+		collection: res?.sharedObjects?.filter((object: any) => object?.module === 'collection')?.[0]
+			?.id,
+		marketplace: res?.sharedObjects?.filter((object: any) => object?.module === 'marketplace')?.[0]
+			?.id,
+		royaltyStrategy: res?.sharedObjects?.filter(
+			(object: any) => object?.module === 'royalty_strategy_bps',
+		)?.[0]?.id,
+		keepsakeRoyaltyStrategy: res?.sharedObjects?.filter(
+			(object: any) => object?.module === 'keepsake_royalties',
+		)?.[0]?.id,
+		transferPolicy,
+		allowList,
+	};
+};

package/src/helpers/getSuiToUsdRate.ts

@@ -0,0 +1,17 @@
+import { gqlChainRequest } from '../graphql/gqlChainRequest';
+import { fetchCryptoToUsdRate } from '../graphql/queries/fetchCryptoToUsdRate';
+
+export const getSuiToUsdRate = async (): Promise<number> => {
+	try {
+		const res = await gqlChainRequest({
+			chain: 'sui',
+			query: fetchCryptoToUsdRate,
+			variables: { crypto: 'sui' },
+		});
+
+		return res?.crypto_rates?.[0]?.rate;
+	} catch (e) {
+		console.log(e);
+		// TODO alert that the rate could not be fetched
+	}
+};

package/src/helpers/getTradeportBiddingContractParsedBidAmount.ts

@@ -0,0 +1,32 @@
+import {
+	BASC_ROYALTY_DECIMAL_PERCENT,
+	DSL_LEGACY_ROYALTY_DECIMAL_PERCENT,
+	MASC_ROYALTY_DECIMAL_PERCENT,
+} from '../constants';
+import { parseSUI } from '../utils/parseSUI';
+
+interface Args {
+	bidAmount: number;
+	collectionId: string;
+}
+
+export const getTradeportBiddingContractParsedBidAmount = ({ bidAmount, collectionId }: Args) => {
+	let amount = bidAmount;
+
+	// MASC
+	if (collectionId === '8568521c-73a3-4beb-b830-d1ff27a3f1ca') {
+		amount = bidAmount - bidAmount * MASC_ROYALTY_DECIMAL_PERCENT;
+	}
+
+	// BASC
+	if (collectionId === '6824e1ff-477e-4810-9ba7-8d6387b68c7d') {
+		amount = bidAmount - bidAmount * BASC_ROYALTY_DECIMAL_PERCENT;
+	}
+
+	// DSL Legacy
+	if (collectionId === '307c7e7a-be3a-43a5-ae44-37f3a37d01f9') {
+		amount = bidAmount - bidAmount * DSL_LEGACY_ROYALTY_DECIMAL_PERCENT;
+	}
+
+	return Number(parseSUI(amount));
+};

package/src/helpers/hasRoyaltyRule.ts

@@ -0,0 +1,14 @@
+import kioskClient from '../apiClients/kioskClient';
+import { addLeadingZerosAfter0x } from '../utils/addLeadingZerosAfter0x';
+
+export const hasRoyaltyRule = async (nftType: string): Promise<boolean> => {
+	const nftTypeSplit = nftType?.split('::');
+	if (nftTypeSplit?.[0]) nftTypeSplit[0] = addLeadingZerosAfter0x(nftTypeSplit[0]);
+
+	const res = await kioskClient.getTransferPolicies({ type: nftTypeSplit?.join('::') });
+
+	return res?.some(
+		(policy: any) =>
+			policy?.rules?.filter((rule: any) => rule?.includes('royalty_rule'))?.length > 0,
+	);
+};

package/src/helpers/hasTransferPolicyRules.ts

@@ -0,0 +1,21 @@
+import kioskClient from '../apiClients/kioskClient';
+import { addLeadingZerosAfter0x } from '../utils/addLeadingZerosAfter0x';
+
+export const hasTransferPolicyRules = async (nftType: string): Promise<boolean> => {
+	const nftTypeSplit = nftType?.split('::');
+	if (nftTypeSplit?.[0]) nftTypeSplit[0] = addLeadingZerosAfter0x(nftTypeSplit[0]);
+
+	// const res = await gqlChainRequest({
+	// 	chain: 'sui',
+	// 	query: fetchTransferPoliciesByType,
+	// 	variables: { type: nftTypeSplit?.join('::') },
+	// });
+
+	// return res?.transfer_policies_by_type
+	// 	?.filter((policy: any) => !policy?.is_origin_byte)
+	// 	?.some((policy: any) => policy?.rules?.length > 0);
+
+	const res = await kioskClient.getTransferPolicies({ type: nftTypeSplit?.join('::') });
+
+	return res?.some((policy: any) => policy?.rules?.length > 0);
+};

package/src/helpers/isNonKioskListing.ts

@@ -0,0 +1,7 @@
+import { NON_KIOSK_LISTING_NONCE_TYPE } from '../constants';
+import { getObjectType } from './rpc/getObjectType';
+
+export const isNonKioskListing = async (listingNonce: string): Promise<boolean> => {
+	const listingType = await getObjectType(listingNonce);
+	return listingType === NON_KIOSK_LISTING_NONCE_TYPE;
+};

package/src/helpers/kiosk/getRulePackageId.ts

@@ -0,0 +1,26 @@
+import { getNormalizedRuleType } from '@mysten/kiosk';
+import kioskClient from '../../apiClients/kioskClient';
+import { addHexPrefix } from '../../utils/addHexPrefix';
+
+type RuleType = 'kiosk_royalty_rule' | 'royalty_rule' | 'personal_kiosk_rule' | 'kiosk_lock_rule';
+
+export const getRulePackageId = async (nftType: string, ruleType: RuleType) => {
+	const transferPolicies = await kioskClient.getTransferPolicies({
+		type: nftType,
+	});
+
+	const rule = transferPolicies
+		.flatMap((policy) => policy.rules)
+		.filter((rule) => rule?.split('::')?.[1] === ruleType)?.[0];
+
+	const ruleDefinition = kioskClient.rules.find(
+		(x) => getNormalizedRuleType(x.rule) === getNormalizedRuleType(rule),
+	);
+
+	let rulePackageId = ruleDefinition?.packageId;
+	if (!rulePackageId) {
+		rulePackageId = rule?.split('::')?.[0];
+	}
+
+	return addHexPrefix(rulePackageId);
+};

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/kioskTxWrapper.ts

@@ -0,0 +1,102 @@
+import { KioskTransaction } from '@mysten/kiosk';
+import { type TransactionBlock } from '@mysten/sui.js/transactions';
+import kioskClient from '../../apiClients/kioskClient';
+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';
+
+type Args = {
+	txBlock: TransactionBlock;
+	kioskOwner: string;
+	kiosk?: any;
+	tx: (kioskTx: KioskTransaction) => Promise<void>;
+	shouldConvertToPersonalKiosk?: boolean;
+};
+
+export const kioskTxWrapper = async ({
+	txBlock,
+	kioskOwner,
+	kiosk,
+	tx,
+	shouldConvertToPersonalKiosk,
+}: Args) => {
+	let kioskTx: KioskTransaction;
+	let kiosks = ((
+		await gqlChainRequest({
+			chain: 'sui',
+			query: fetchKiosksByOwner,
+			variables: { ownerAddress: addLeadingZerosAfter0x(kioskOwner) },
+		})
+	).kiosks ?? []) as Array<{
+		id: string;
+		is_personal: boolean;
+		is_origin_byte: boolean;
+	}>;
+
+	kiosks = kiosks?.filter((k) => !k.is_origin_byte);
+
+	if (kiosk) {
+		const filteredKiosks = kiosks.filter((k) => k?.id === kiosk);
+		if (filteredKiosks.length > 0) {
+			kiosks = filteredKiosks;
+		}
+	}
+
+	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({
+			transactionBlock: txBlock as any,
+			kioskClient,
+			cap: {
+				isPersonal: true,
+				objectId: personalKioskCapId,
+				kioskId: personalKiosk.id,
+				digest: '',
+				version: '',
+			},
+		});
+	} else if (kiosks.length > 0) {
+		const kioskCapId = (
+			await gqlChainRequest({
+				chain: 'sui',
+				query: fetchOwnerCapByKiosk,
+				variables: { kioskId: kiosks[0].id },
+			})
+		).ownerCap?.id;
+
+		kioskTx = new KioskTransaction({
+			transactionBlock: txBlock as any,
+			kioskClient,
+			cap: {
+				isPersonal: false,
+				objectId: kioskCapId,
+				kioskId: kiosks[0].id,
+				digest: '',
+				version: '',
+			},
+		});
+
+		if (shouldConvertToPersonalKiosk) {
+			kioskTx.convertToPersonal(true);
+		}
+	} else {
+		// creating new personal kiosk
+		kioskTx = new KioskTransaction({ transactionBlock: txBlock as any, kioskClient });
+		kioskTx.createPersonal(true);
+	}
+
+	await tx(kioskTx);
+	kioskTx.finalize();
+};

package/src/helpers/kiosk/resolveFloorPriceRule.ts

@@ -0,0 +1,25 @@
+import { type ObjectArgument } from '@mysten/kiosk';
+import { type TransactionObjectArgument } from '@mysten/sui.js/dist/cjs/builder';
+import { type TransactionBlock } from '@mysten/sui.js/transactions';
+
+type Args = {
+	txBlock: TransactionBlock;
+	packageId: string;
+	transferRequest: TransactionObjectArgument;
+	nftType: string;
+	policyId: ObjectArgument;
+};
+
+export function resolveFloorPriceRule({
+	txBlock,
+	packageId,
+	nftType,
+	policyId,
+	transferRequest,
+}: Args) {
+	txBlock.moveCall({
+		target: `${packageId}::floor_price_rule::prove`,
+		typeArguments: [nftType],
+		arguments: [txBlock.object(policyId), transferRequest],
+	});
+}

package/src/helpers/kiosk/resolveKioskLockRule.ts

@@ -0,0 +1,49 @@
+import { type ObjectArgument } from '@mysten/kiosk';
+import { type TransactionBlock, type TransactionObjectArgument } from '@mysten/sui.js/transactions';
+
+type Args = {
+	txBlock: TransactionBlock;
+	policyId: ObjectArgument;
+	packageId: string;
+	transferRequest: TransactionObjectArgument;
+	nftType: string;
+	kiosk: ObjectArgument;
+	kioskCap: ObjectArgument;
+	kioskItem?: ObjectArgument;
+	shouldSkipLocking?: boolean;
+};
+
+export function resolveKioskLockRule({
+	txBlock,
+	packageId,
+	policyId,
+	transferRequest,
+	nftType,
+	kiosk,
+	kioskCap,
+	kioskItem,
+	shouldSkipLocking,
+}: Args) {
+	if (!kiosk || !kioskCap) throw new Error('Missing Owned Kiosk or Owned Kiosk Cap');
+
+	if (!shouldSkipLocking) {
+		if (!kioskItem) throw new Error('Missing Kiosk Item');
+
+		txBlock.moveCall({
+			target: '0x2::kiosk::lock',
+			typeArguments: [nftType],
+			arguments: [
+				txBlock.object(kiosk),
+				txBlock.object(kioskCap),
+				txBlock.object(policyId),
+				txBlock.object(kioskItem),
+			],
+		});
+	}
+
+	txBlock.moveCall({
+		target: `${packageId}::kiosk_lock_rule::prove`,
+		typeArguments: [nftType],
+		arguments: [transferRequest, txBlock.object(kiosk)],
+	});
+}

package/src/helpers/kiosk/resolvePersonalKioskRule.ts

@@ -0,0 +1,26 @@
+import { type ObjectArgument } from '@mysten/kiosk';
+import { type TransactionBlock, type TransactionObjectArgument } from '@mysten/sui.js/transactions';
+
+type Args = {
+	txBlock: TransactionBlock;
+	packageId: string;
+	transferRequest: TransactionObjectArgument;
+	nftType: string;
+	kiosk: ObjectArgument;
+};
+
+export function resolvePersonalKioskRule({
+	txBlock,
+	packageId,
+	nftType,
+	kiosk,
+	transferRequest,
+}: Args) {
+	if (!kiosk) throw new Error('Missing owned Kiosk.');
+
+	txBlock.moveCall({
+		target: `${packageId}::personal_kiosk_rule::prove`,
+		typeArguments: [nftType],
+		arguments: [txBlock.object(kiosk), transferRequest],
+	});
+}

package/src/helpers/kiosk/resolveRoyaltyRule.ts

@@ -0,0 +1,41 @@
+import { type ObjectArgument } from '@mysten/kiosk';
+import { type TransactionBlock, type TransactionObjectArgument } from '@mysten/sui.js/transactions';
+
+type Args = {
+	txBlock: TransactionBlock;
+	policyId: ObjectArgument;
+	moduleName: string;
+	packageId: string;
+	transferRequest: TransactionObjectArgument;
+	nftType: string;
+	price?: string;
+	priceObjectArgument?: ObjectArgument;
+};
+
+export function resolveRoyaltyRule({
+	txBlock,
+	packageId,
+	moduleName,
+	policyId,
+	transferRequest,
+	nftType,
+	price,
+	priceObjectArgument,
+}: Args) {
+	const [amount] = txBlock.moveCall({
+		target: `${packageId}::${moduleName}::fee_amount`,
+		typeArguments: [nftType],
+		arguments: [
+			txBlock.object(policyId),
+			priceObjectArgument ? txBlock.object(priceObjectArgument) : txBlock.pure(price || '0'),
+		],
+	});
+
+	const feeCoin = txBlock.splitCoins(txBlock.gas, [amount]);
+
+	txBlock.moveCall({
+		target: `${packageId}::${moduleName}::pay`,
+		typeArguments: [nftType],
+		arguments: [txBlock.object(policyId), transferRequest, feeCoin],
+	});
+}