@tradeport/sui-trading-sdk 0.5.3 → 0.5.5

package/src/helpers/calculatePremium.ts

@@ -0,0 +1,9 @@
+import { PREMIUM_FEE_NOMINATOR, PREMIUM_NOMINATOR } from '../constants';
+
+export function calculatePremium(price: bigint): bigint {
+	return (BigInt(price) * PREMIUM_NOMINATOR) / 10_000n;
+}
+
+export function calculatePremiumFee(premium: bigint): bigint {
+	return (BigInt(premium) * PREMIUM_FEE_NOMINATOR) / 10_000n;
+}

package/src/helpers/calculateRoyaltyFee.ts

@@ -0,0 +1,28 @@
+import BigNumber from '../bigNumberConfig';
+import { ZERO } from '../bigNumberConfig';
+
+export function calculateRoyaltyFee(
+	transferPolicyRules: Array<{ type: string; amount_bp?: string; min_amount?: string }>,
+	price: BigNumber,
+): BigNumber {
+	const royaltyRule = transferPolicyRules?.filter(
+		(rule: { type: string }) => rule.type === 'royalty_rule' || rule.type === 'kiosk_royalty_rule',
+	)?.[0];
+
+	if (!royaltyRule || (!royaltyRule.amount_bp && !royaltyRule.min_amount)) {
+		return ZERO;
+	}
+
+	const royaltyFee = royaltyRule.amount_bp
+		? new BigNumber(royaltyRule.amount_bp)
+				.times(price)
+				.div(10000)
+				.integerValue(BigNumber.ROUND_DOWN)
+		: ZERO;
+
+	if (royaltyRule.min_amount && new BigNumber(royaltyRule.min_amount).isGreaterThan(royaltyFee)) {
+		return new BigNumber(royaltyRule.min_amount);
+	}
+
+	return royaltyFee;
+}

package/src/helpers/destroyZeroCoin.ts

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

package/src/helpers/getActiveLockStateByNftId.ts

@@ -0,0 +1,15 @@
+import { gqlChainRequest } from '../graphql/gqlChainRequest';
+import { type Lock } from './getLockById';
+import { fetchActiveLockStateByNftId } from '../graphql/queries/fetchActiveLockStateByNftId';
+
+export const getActiveLockStateByNftId = async (
+	nftId: string,
+): Promise<Pick<Lock, 'id' | 'state'>> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchActiveLockStateByNftId,
+		variables: { nftId },
+	});
+
+	return res?.locks?.[0] ?? undefined;
+};

package/src/helpers/getCollectionChainState.ts

@@ -0,0 +1,31 @@
+import { gqlChainRequest } from '../graphql/gqlChainRequest';
+import {
+	fetchCollectionChainState,
+	fetchCollectionChainStateByFtType,
+} from '../graphql/queries/fetchCollectionChainState';
+
+export const getCollectionChainState = async (
+	collectionId: string,
+): Promise<Record<string, unknown> | undefined> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchCollectionChainState,
+		variables: { collectionId },
+	});
+
+	return res?.collections?.[0]?.chain_state;
+};
+
+export const getCollectionChainStateByFtType = async (
+	ftType: string,
+): Promise<Record<string, unknown> | undefined> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchCollectionChainStateByFtType,
+		variables: {
+			ftType,
+		},
+	});
+
+	return res?.collections_by_ft_type?.[0]?.chain_state;
+};

package/src/helpers/getCollectionFloorPrice.ts

@@ -0,0 +1,12 @@
+import { gqlChainRequest } from '../graphql/gqlChainRequest';
+import { fetchCollectionFloorListings } from '../graphql/queries/fetchCollectionFloorListings';
+
+export const getCollectionFloorPrice = async (collectionId: string) => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchCollectionFloorListings,
+		variables: { collectionId },
+	});
+
+	return res?.listings?.[0]?.price;
+};

package/src/helpers/getLockById.ts

@@ -0,0 +1,29 @@
+import { gqlChainRequest } from '../graphql/gqlChainRequest';
+import { fetchLockById } from '../graphql/queries/fetchLockById';
+
+export type Lock = {
+	id: string;
+	lock_id: string;
+	chain_state?: Record<string, any>;
+	nft_type: string;
+	type: string;
+	state: string;
+	maker_price: bigint;
+	maker: string;
+	collection_id: string;
+	expire_in: number;
+	nft?: {
+		id: string;
+		token_id: string;
+	};
+};
+
+export const getLockById = async (lockId: string): Promise<Lock | undefined> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchLockById,
+		variables: { lockId },
+	});
+
+	return res?.locks?.[0] ?? undefined;
+};

package/src/helpers/getMarketFeePrice.ts

@@ -0,0 +1,82 @@
+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;
+	marketFeeDecimalPercent?: number;
+};
+
+export const getMarketFeePrice = ({
+	price,
+	collectionId,
+	marketFeeDecimalPercent,
+}: 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);
+	}
+
+	let marketFeePrice = 0;
+
+	if (!COLLECTION_IDS_WITH_ZERO_COMMISSION?.includes(collectionId)) {
+		marketFeePrice = price * TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT;
+
+		if (marketFeeDecimalPercent) {
+			marketFeePrice = price * marketFeeDecimalPercent;
+		}
+	}
+
+	if (marketFeePrice < 1) {
+		return marketFeePrice;
+	}
+
+	return parseInt(marketFeePrice?.toFixed(0), 10);
+};

package/src/helpers/getNftType.ts

@@ -0,0 +1,38 @@
+interface CollectionChainState {
+	nft_type: string;
+}
+
+interface NFT {
+	properties?: {
+		nft_type?: string;
+	};
+	contract?: {
+		properties?: {
+			nft_type?: string;
+		};
+	};
+}
+
+export const getNftType = ({
+	collectionId,
+	collectionChainState,
+	nft,
+}: {
+	collectionId: string;
+	collectionChainState?: CollectionChainState;
+	nft?: NFT;
+}): string => {
+	if (collectionId === 'a6fabb11-4713-4203-bce8-a3c4f673b5a7') {
+		// dungeon move, each nft has different type based off it's identity, so use nft.properties.nft_type
+		return nft?.properties?.nft_type;
+	}
+
+	if (collectionChainState?.nft_type) return collectionChainState.nft_type;
+
+	let nftType = nft?.properties?.nft_type;
+	if (!nftType || nftType?.split('::')?.length <= 1) {
+		nftType = nft?.contract?.properties?.nft_type;
+	}
+
+	return nftType ?? '';
+};

package/src/helpers/getRoyaltyRuleModule.ts

@@ -0,0 +1,7 @@
+import { normalizedNftType } from '../utils/normalizeNftType';
+
+export const getRoyaltyRuleModule = (nftType: string) =>
+	normalizedNftType(nftType) ===
+	'0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard'
+		? 'kiosk_royalty_rule'
+		: 'royalty_rule';

package/src/helpers/getSharedObjects.ts

@@ -0,0 +1,119 @@
+import {
+	CRYPTOPEDIA_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	FUDDIES_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	GNOMES_ORIGIN_BYTE_ALLOW_LIST_OBJECT,
+	NOVAGEN_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;
+	}
+
+	if (
+		nftType ===
+		'0xf417417b1914266b634b3dc90050be9f28fb755e9d29f36d1892012e0ad6f816::novagen::Novagen'
+	) {
+		allowList = NOVAGEN_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+	}
+
+	const transferPolicy = res?.sharedObjects?.filter(
+		(object: any) => object?.module === 'transfer_policy',
+	)?.[0]?.id;
+
+	let orderbook = res?.sharedObjects?.filter((object: any) => object?.module === 'orderbook')?.[0]
+		?.id;
+
+	if (nftTypeSplit?.join('::')?.includes('keepsake_nft::KEEPSAKE')) {
+		orderbook = null;
+	}
+
+	return {
+		orderbook,
+		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,14 @@
+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) {}
+};

package/src/helpers/getTradeportBiddingContractBidAmount.ts

@@ -0,0 +1,31 @@
+import {
+	BASC_ROYALTY_DECIMAL_PERCENT,
+	DSL_LEGACY_ROYALTY_DECIMAL_PERCENT,
+	MASC_ROYALTY_DECIMAL_PERCENT,
+} from '../constants';
+
+interface Args {
+	bidAmount: number;
+	collectionId: string;
+}
+
+export const getTradeportBiddingContractBidAmount = ({ 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 amount;
+};

package/src/helpers/getTransferPolicyRuleNamesFromSuiObject.ts

@@ -0,0 +1,24 @@
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { normalizeStructTag, normalizeSuiObjectId } from '@mysten/sui/utils';
+
+export const getTransferPolicyRuleNamesFromSuiObject = async ({
+	suiClient,
+	transferPolicyId,
+}: {
+	suiClient: SuiGrpcClient;
+	transferPolicyId: string;
+}) => {
+	const { object } = await suiClient.getObject({
+		objectId: normalizeSuiObjectId(transferPolicyId),
+		include: { json: true },
+	});
+
+	const content = object.json as unknown as {
+		rules: {
+			contents: string[];
+		};
+	};
+	const ruleNames = content.rules.contents.map((rule) => normalizeStructTag(rule));
+
+	return ruleNames;
+};

package/src/helpers/hasPersonalKioskRule.ts

@@ -0,0 +1,7 @@
+import { getNativeKioskTransferPolicies } from './kiosk/getNativeKioskTransferPolicies';
+
+export const hasPersonalKioskRule = (transferPolicies: any): boolean =>
+	getNativeKioskTransferPolicies(transferPolicies)?.some(
+		(policy: any) =>
+			policy?.rules?.filter((rule: any) => rule?.type?.includes('personal_kiosk_rule'))?.length > 0,
+	);

package/src/helpers/hasRoyaltyRule.ts

@@ -0,0 +1,7 @@
+import { getNativeKioskTransferPolicies } from './kiosk/getNativeKioskTransferPolicies';
+
+export const hasRoyaltyRule = (transferPolicies: any): boolean =>
+	getNativeKioskTransferPolicies(transferPolicies)?.some(
+		(policy: any) =>
+			policy?.rules?.filter((rule: any) => rule?.type?.includes('royalty_rule'))?.length > 0,
+	);

package/src/helpers/hasTransferPolicyRules.ts

@@ -0,0 +1,6 @@
+import { getNativeKioskTransferPolicies } from './kiosk/getNativeKioskTransferPolicies';
+
+export const hasNativeKioskTransferPolicyRules = (transferPolicies: any): boolean => {
+	const nativeKioskTransferPolicies = getNativeKioskTransferPolicies(transferPolicies);
+	return nativeKioskTransferPolicies?.some((policy: any) => policy?.rules?.length > 0);
+};

package/src/helpers/isExpiredListing.ts

@@ -0,0 +1,9 @@
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+
+export const isExpiredListing = (
+	listing: { nonce?: string; seller?: string },
+	walletAddress: string,
+) =>
+	listing.nonce &&
+	listing.seller &&
+	normalizeSuiAddress(listing.seller) === normalizeSuiAddress(walletAddress);

package/src/helpers/isNonKioskListing.ts

@@ -0,0 +1,14 @@
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { NON_KIOSK_LISTING_NONCE_TYPE } from '../constants';
+import { getObjectType } from './rpc/getObjectType';
+
+export const isNonKioskListing = async ({
+	suiClient,
+	listingNonce,
+}: {
+	suiClient: SuiGrpcClient;
+	listingNonce: string;
+}): Promise<boolean> => {
+	const listingType = await getObjectType({ suiClient, objectId: listingNonce });
+	return listingType === NON_KIOSK_LISTING_NONCE_TYPE;
+};

package/src/helpers/isSIngleBid.ts

@@ -0,0 +1,13 @@
+import { TRADEPORT_MULTI_BID_PACKAGE_ORIGINAL } from '../constants';
+
+export const isSingleBid = (bidType: string): boolean => {
+	if (!bidType) {
+		return false;
+	}
+
+	if (!bidType.startsWith('0x')) {
+		bidType = `0x${bidType}`;
+	}
+
+	return bidType === `${TRADEPORT_MULTI_BID_PACKAGE_ORIGINAL}::tradeport_biddings::SingleBid`;
+};

package/src/helpers/kiosk/assertNftInSharedKiosk.ts

@@ -0,0 +1,31 @@
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchKiosksByOwner } from '../../graphql/queries/fetchKiosksByOwner';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { type SharedKioskState } from './sharedKioskState.type';
+
+export const assertNftInSharedKiosk = async ({
+	kioskId,
+	walletAddress,
+	sharedKioskState,
+}: {
+	kioskId: string;
+	walletAddress: string;
+	sharedKioskState?: SharedKioskState;
+}): Promise<void> => {
+	if (!sharedKioskState?.ownerKiosks) {
+		const res = await gqlChainRequest({
+			chain: 'sui',
+			query: fetchKiosksByOwner,
+			variables: { ownerAddress: addLeadingZerosAfter0x(walletAddress) },
+		});
+		if (sharedKioskState) {
+			sharedKioskState.ownerKiosks = res?.kiosks;
+		}
+	}
+
+	const nftKiosk = sharedKioskState?.ownerKiosks?.find((k: any) => k.id === kioskId);
+
+	if (nftKiosk && !nftKiosk?.is_shared) {
+		throw new Error('NFT is inside a kiosk that is not shared');
+	}
+};

package/src/helpers/kiosk/getKioskCollectionRoyaltyFeeAmount.ts

@@ -0,0 +1,71 @@
+import { bcs } from '@mysten/sui/bcs';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import {
+	Transaction,
+	type TransactionArgument,
+	type TransactionObjectInput,
+} from '@mysten/sui/transactions';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+
+interface Args {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	walletAddress: string;
+	royaltyRulePackageId: string;
+	royaltyRuleModule: string;
+	transferPolicyId: string | TransactionObjectInput;
+	price: number | string;
+	nftType: string;
+}
+
+export async function getKioskCollectionRoyaltyFeeAmount({
+	tx,
+	suiClient,
+	walletAddress,
+	royaltyRulePackageId,
+	royaltyRuleModule,
+	transferPolicyId,
+	price,
+	nftType,
+}: Args): Promise<TransactionArgument | bigint | undefined> {
+	if (!royaltyRulePackageId || !royaltyRuleModule || !transferPolicyId || !nftType) {
+		console.warn('Missing required parameters for royalty fee calculation');
+		return undefined;
+	}
+
+	if (!price) {
+		console.warn('Price is undefined or 0');
+		return undefined;
+	}
+
+	const feeTx = new Transaction();
+	feeTx.moveCall({
+		target: `${royaltyRulePackageId}::${royaltyRuleModule}::fee_amount`,
+		arguments: [feeTx.object(transferPolicyId), feeTx.pure.u64(price)],
+		typeArguments: [nftType],
+	});
+
+	feeTx.setSender(addLeadingZerosAfter0x(walletAddress));
+	const res = await suiClient.simulateTransaction({
+		transaction: feeTx,
+		include: { commandResults: true },
+		checksEnabled: false,
+	});
+
+	let feeAmount: TransactionArgument | bigint | undefined;
+	const returnedAmount = res?.commandResults?.[0]?.returnValues?.[0]?.bcs;
+	if (returnedAmount) {
+		feeAmount = BigInt(bcs.U64.parse(returnedAmount));
+	}
+
+	// We were not able to calculate the amount outside of the transaction, so fall back to resolving it within the PTB
+	if (!feeAmount && feeAmount !== 0n) {
+		[feeAmount] = tx.moveCall({
+			target: `${royaltyRulePackageId}::${royaltyRuleModule}::fee_amount`,
+			typeArguments: [nftType],
+			arguments: [tx.object(transferPolicyId), tx.pure.u64(price)],
+		});
+	}
+
+	return feeAmount;
+}

package/src/helpers/kiosk/getKioskIdFromKioskTx.ts

@@ -0,0 +1,29 @@
+import { type KioskTransaction } from '@mysten/kiosk';
+import { type Transaction } from '@mysten/sui/transactions';
+
+export const getKioskIdFromKioskTx = ({
+	kioskTx,
+	tx,
+}: {
+	kioskTx: KioskTransaction;
+	tx: Transaction;
+}): string => {
+	const kioskArg = kioskTx.kiosk as any;
+
+	if (!kioskArg || !('Input' in kioskArg)) {
+		throw new Error('Invalid kiosk transaction structure');
+	}
+
+	const input = (tx as any).getData().inputs[kioskArg.Input];
+	const kioskId =
+		input?.UnresolvedObject?.objectId ??
+		input?.Object?.ImmOrOwnedObject?.objectId ??
+		input?.Object?.SharedObject?.objectId ??
+		input?.Object?.Receiving?.objectId;
+
+	if (!kioskId) {
+		throw new Error('Invalid kiosk transaction structure');
+	}
+
+	return kioskId;
+};