@tradeport/sui-trading-sdk 0.5.3 → 0.5.4

package/src/methods/buyListings/addBuyListingTxs.ts

@@ -0,0 +1,806 @@
+import { bcs } from '@mysten/sui/bcs';
+import { KioskListing } from '../../helpers/kiosk/kioskListingBcs';
+import {
+	BLUEMOVE_CREATOR_CONFIG_OBJECT,
+	BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT,
+	BLUEMOVE_MARKET_CONFIG_OBJECT,
+	BLUEMOVE_ROYALTY_COLLECTION_OBJECT,
+	HYPERSPACE_MP_TRANSFER_POLICY_TYPE,
+	HYPERSPACE_TRANSFER_POLICY_TYPE,
+	KEEPSAKE_MARKETPLACE_KIOSK,
+	KEEPSAKE_MARKETPLACE_OBJECT,
+	NON_KIOSK_LISTING_NONCE_TYPE,
+	SOUFFL3_EXTENSION_OBJECT,
+	SOUFFL3_GENERIC_BUY_METHOD_COLLECTIONS,
+	SOUFFL3_MARKETPLACE_OBJECT,
+	SOUFFL3_VERSION_OBJECT,
+	TOCEN_MARKETPLACE_OBJECT,
+	TRADEPORT_LISTINGS_DEFAULT_COMMISSION_BPS,
+	TRADEPORT_KIOSK_LISTING_STORE,
+	TRADEPORT_LISTING_STORE,
+	TRADEPORT_LISTINGS_PACKAGE,
+	CUSTOM_TRANSFER_RULES_BY_COLLECTION,
+	TRADEPORT_LISTINGS_STORE,
+	XOCIETY_FRONTIER_COLLECTION_ID,
+	TRADEPORT_ORDERBOOK_STORE,
+} from '../../constants';
+import { getCommissionByNftContractId } from '../../graphql/queries/getCommissionByListingId';
+import { destroyZeroCoin } from '../../helpers/destroyZeroCoin';
+import { getMarketFeePrice } from '../../helpers/getMarketFeePrice';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { assertNftInSharedKiosk } from '../../helpers/kiosk/assertNftInSharedKiosk';
+import { getNativeKioskTransferPolicies } from '../../helpers/kiosk/getNativeKioskTransferPolicies';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { resolveCustomTransferPolicyRules } from '../../helpers/kiosk/resolveCustomTransferPolicyRules';
+import { resolveTransferPolicies } from '../../helpers/kiosk/resolveTransferPolicies';
+import { confirmOBTranfer } from '../../helpers/originByte/confirmOBTranfer';
+import { getOrCreateOBKiosk } from '../../helpers/originByte/getOrCreateOBKiosk';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { shareOriginByteKiosk } from '../../helpers/originByte/shareOriginByteKiosk';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { type BuyTx, type TocenBuyTx } from './buyListings';
+import BigNumber from '../../bigNumberConfig';
+import { calculateRoyaltyFee } from '../../helpers/calculateRoyaltyFee';
+import { getCollectionChainState } from '../../helpers/getCollectionChainState';
+import { normalizeSuiObjectId } from '@mysten/sui/utils';
+import { applyFtStrategy } from '../applyFtStrategy/applyFtStrategy';
+
+export function addLegacyTradePortBuyTx({
+	tx,
+	nftType,
+	listingNonce,
+	price,
+	sharedObjects,
+	coinToSplit,
+}: BuyTx) {
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(price)]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const { collection, royaltyStrategy } = sharedObjects;
+	if (collection && royaltyStrategy) {
+		tx.moveCall({
+			target:
+				'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::ob_buy',
+			arguments: [
+				tx.object(TRADEPORT_LISTING_STORE),
+				tx.pure.address(listingNonce),
+				tx.object(coin),
+				tx.object(collection),
+				tx.object(royaltyStrategy),
+			],
+			typeArguments: [nftType],
+		});
+	} else {
+		tx.moveCall({
+			target: '0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::buy',
+			arguments: [
+				tx.object(TRADEPORT_LISTING_STORE),
+				tx.pure.address(listingNonce),
+				tx.object(coin),
+			],
+			typeArguments: [nftType],
+		});
+	}
+
+	destroyZeroCoin({ tx, coin });
+}
+
+export const addLegacyTradeportKioskBuyTx = async ({
+	tx,
+	transferPolicies,
+	kioskTx,
+	suiClient,
+	kioskClient,
+	listingId,
+	nftType,
+	nftTokenId,
+	price,
+	sellerKiosk,
+	seller,
+	coinToSplit,
+	beforeResolveKioskTransferRequest,
+	sharedBulkBuyingDataByNftType,
+	collectionId,
+}: BuyTx) => {
+	let commissionFeeAmount: number =
+		sharedBulkBuyingDataByNftType?.[nftType]?.commissionFeeAmountsByListingId?.[listingId] ?? 0;
+
+	if (!commissionFeeAmount) {
+		try {
+			const { object } = await suiClient.core.getDynamicObjectField({
+				parentId: TRADEPORT_KIOSK_LISTING_STORE,
+				name: { type: '0x2::object::ID', bcs: bcs.Address.serialize(nftTokenId).toBytes() },
+				include: { content: true },
+			});
+			commissionFeeAmount = Number(KioskListing.parse(object.content).commission);
+		} catch {
+			throw new Error(`Not found kiosk listing object of token ${nftTokenId}`);
+		}
+	}
+
+	if (commissionFeeAmount === 0) {
+		// Fallback to default commission if had trouble fetching commission from dynamic field object
+		commissionFeeAmount = getMarketFeePrice({ price, collectionId });
+	}
+
+	const coin = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [
+		tx.pure.u64(price + commissionFeeAmount),
+	]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const [kioskItem, transferRequest] = tx.moveCall({
+		target:
+			'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_listings::buy',
+		arguments: [
+			tx.object(TRADEPORT_KIOSK_LISTING_STORE),
+			tx.object(sellerKiosk),
+			tx.object(kioskTx.kiosk),
+			tx.pure.address(nftTokenId),
+			tx.object(coin),
+		],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		tx,
+		transferPolicies,
+		suiClient,
+		walletAddress: seller,
+		kioskTx,
+		kioskClient,
+		nftType,
+		price: price?.toString(),
+		kioskItem,
+		transferRequest,
+		coinToSplit,
+		beforeResolveKioskTransferRequest,
+		transferPoliciesToResolve: sharedBulkBuyingDataByNftType?.[nftType]?.transferPoliciesToResolve,
+		royaltyFeeAmount:
+			sharedBulkBuyingDataByNftType?.[nftType]?.royaltyFeeAmountsByListingId?.[listingId],
+	});
+
+	destroyZeroCoin({ tx, coin });
+};
+
+export async function addTradePortBuyTx({ tx, nftType, nftTokenId, price, coinToSplit }: BuyTx) {
+	const marketFee = new BigNumber(price)
+		.times(TRADEPORT_LISTINGS_DEFAULT_COMMISSION_BPS)
+		.div(10_000)
+		.integerValue(BigNumber.ROUND_DOWN)
+		.toNumber();
+	const totalAmount = new BigNumber(price).plus(marketFee).toNumber();
+
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(totalAmount)]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::buy_ob_listing_without_transfer_policy`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(TRADEPORT_ORDERBOOK_STORE),
+			tx.pure.id(nftTokenId),
+			tx.object(coin),
+		],
+		typeArguments: [nftType],
+	});
+
+	destroyZeroCoin({ tx, coin });
+}
+
+export async function addKioskTradePortBuyTx({
+	tx,
+	transferPolicies,
+	kioskTx,
+	nftType,
+	nftTokenId,
+	price,
+	sellerKiosk,
+	coinToSplit,
+	buyer,
+	collectionId,
+}: BuyTx) {
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const marketFee = new BigNumber(price)
+		.times(TRADEPORT_LISTINGS_DEFAULT_COMMISSION_BPS)
+		.div(10000)
+		.integerValue(BigNumber.ROUND_DOWN);
+
+	const royaltyFee = calculateRoyaltyFee(
+		getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.rules,
+		new BigNumber(price),
+	);
+
+	const totalAmount = new BigNumber(price).plus(marketFee).plus(royaltyFee).toNumber();
+
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(totalAmount)]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const transferRequest = tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::buy_ob_listing_with_transfer_policy`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(TRADEPORT_ORDERBOOK_STORE),
+			tx.object(sellerKiosk),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(buyer),
+			tx.pure.id(nftTokenId),
+			tx.object(coin),
+			tx.object(transferPolicyId),
+		],
+		typeArguments: [nftType],
+	});
+
+	// Resolve custom transfer policy rules if this collection has any
+	const customRuleConfigs = CUSTOM_TRANSFER_RULES_BY_COLLECTION[collectionId];
+	if (customRuleConfigs?.length > 0) {
+		resolveCustomTransferPolicyRules({
+			tx,
+			rules: customRuleConfigs.map((config) => ({
+				rule: `${config.packageId}::${config.moduleName}`,
+				rulePackageId: config.packageId,
+				moduleName: config.moduleName,
+				params: config.params,
+			})),
+			transferRequest,
+			nftType,
+			policyId: transferPolicyId,
+		});
+	}
+
+	tx.moveCall({
+		target: '0x2::transfer_policy::confirm_request',
+		arguments: [tx.object(transferPolicyId), transferRequest],
+		typeArguments: [nftType],
+	});
+
+	destroyZeroCoin({ tx, coin });
+}
+
+export async function addOriginByteBuyTx({
+	tx,
+	sharedObjects,
+	buyer,
+	sellerKiosk,
+	seller,
+	nftTokenId,
+	nftType,
+	listingNonce,
+	price,
+	sharedKioskState,
+	coinToSplit,
+}: BuyTx) {
+	await assertNftInSharedKiosk({
+		kioskId: sellerKiosk,
+		walletAddress: seller,
+		sharedKioskState,
+	});
+
+	const { orderbook } = sharedObjects;
+	const { kiosk: buyerKiosk, isNewKiosk: isNewBuyerKiosk } = await getOrCreateOBKiosk({
+		tx,
+		address: buyer,
+		sharedKioskState,
+	});
+
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(price)]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const transferRequest = tx.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::buy_nft',
+		arguments: [
+			tx.object(orderbook),
+			tx.object(listingNonce),
+			tx.object(buyerKiosk),
+			tx.pure.address(nftTokenId),
+			tx.pure.u64(price),
+			tx.object(coin),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	confirmOBTranfer({ tx, sharedObjects, transferRequest, nftType });
+
+	destroyZeroCoin({ tx, coin });
+
+	if (isNewBuyerKiosk) {
+		shareOriginByteKiosk({ tx, kiosk: buyerKiosk });
+	}
+}
+
+export const addHyperspaceKioskBuyTx = async ({
+	tx,
+	transferPolicies,
+	suiClient,
+	kioskTx,
+	kioskClient,
+	nftType,
+	nftTokenId,
+	price,
+	sellerKiosk,
+	seller,
+	beforeResolveKioskTransferRequest,
+	coinToSplit,
+}: BuyTx) => {
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(price)]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const [kioskItem, transferRequest, hyperspaceTransferRequest, hyperspaceMpTransferRequest] =
+		tx.moveCall({
+			target:
+				'0x6ea97b03c441edd54ae89224bf9560e583ee66c37e6c246f5db35258e580ba94::hyperspace::purchase',
+			arguments: [tx.object(sellerKiosk), tx.pure.address(nftTokenId), tx.object(coin)],
+			typeArguments: [nftType, HYPERSPACE_MP_TRANSFER_POLICY_TYPE],
+		});
+
+	const customTransferPolicies = [
+		{
+			type: HYPERSPACE_TRANSFER_POLICY_TYPE,
+			transferRequest: hyperspaceTransferRequest,
+		},
+		{
+			type: HYPERSPACE_MP_TRANSFER_POLICY_TYPE,
+			transferRequest: hyperspaceMpTransferRequest,
+		},
+	].filter((customTransferPolicy) => customTransferPolicy.transferRequest !== transferRequest);
+
+	await beforeResolveKioskTransferRequest?.(transferRequest);
+
+	await resolveTransferPolicies({
+		tx,
+		transferPolicies,
+		suiClient,
+		walletAddress: seller,
+		kioskTx,
+		kioskClient,
+		nftType,
+		price: price?.toString(),
+		kioskItem,
+		transferRequest,
+		customTransferPolicies,
+	});
+};
+
+export function addBluemoveBuyTx({ tx, nftTokenId, nftType, price, coinToSplit }: BuyTx) {
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(price)]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	tx.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::buy_and_take',
+		arguments: [
+			tx.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+			tx.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+			tx.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+			tx.pure.address(nftTokenId),
+			tx.object(coin),
+			tx.pure.u64(price),
+		],
+		typeArguments: [nftType, nftType],
+	});
+}
+
+export async function addBluemoveKioskBuyTx({
+	tx,
+	suiClient,
+	transferPolicies,
+	kioskTx,
+	kioskClient,
+	nftTokenId,
+	nftType,
+	price,
+	sellerKiosk,
+	seller,
+	beforeResolveKioskTransferRequest,
+	coinToSplit,
+}: BuyTx) {
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const [coin1, coin2] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [
+		tx.pure.u64(price),
+		tx.pure.u64(price * 0.025),
+	]);
+
+	if (!coin1 || !coin2) throw new Error('Coin could not be split');
+
+	tx.mergeCoins(tx.object(coin1), [tx.object(coin2)]);
+
+	const [kioskItem, transferRequest] = tx.moveCall({
+		target:
+			'0xcc97b74ed95c8e8a3ed88050a898727dee37896da579fc400d482b64db6149ff::kiosk_trade::kiosk_buy_v2',
+		arguments: [
+			tx.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
+			tx.object(sellerKiosk),
+			tx.object(transferPolicyId),
+			tx.object(kioskTx.kiosk),
+			tx.pure.address(nftTokenId),
+			tx.pure.u64(price),
+			tx.object(coin1),
+		],
+		typeArguments: [nftType],
+	});
+	await beforeResolveKioskTransferRequest?.(transferRequest);
+	await resolveTransferPolicies({
+		tx,
+		transferPolicies,
+		suiClient,
+		walletAddress: seller,
+		kioskTx,
+		kioskClient,
+		nftType,
+		price: price?.toString(),
+		kioskItem,
+		transferRequest,
+	});
+}
+
+export async function addSouffl3BuyTx({
+	tx,
+	nftType,
+	price,
+	listingNonce,
+	collectionId,
+	transferPolicies,
+	coinToSplit,
+}: BuyTx) {
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(price)]);
+
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	if (transferPolicyId && !SOUFFL3_GENERIC_BUY_METHOD_COLLECTIONS?.includes(collectionId)) {
+		const [coinToDestroy] = tx.moveCall({
+			target:
+				'0x30d90b5b67be77e6e06f02dae9f0f2fcdad16e38854316ae8a7b4f5b4971f5e0::Market::buy_with_sui_with_ext',
+			arguments: [
+				tx.object(SOUFFL3_VERSION_OBJECT),
+				tx.object(SOUFFL3_EXTENSION_OBJECT),
+				tx.object(transferPolicyId),
+				tx.object(listingNonce),
+				tx.pure.u64(price),
+				tx.object(SOUFFL3_MARKETPLACE_OBJECT),
+				tx.object(coin),
+			],
+			typeArguments: [nftType],
+		});
+
+		destroyZeroCoin({ tx, coin: coinToDestroy });
+	} else {
+		const [coinToDestroy] = tx.moveCall({
+			target:
+				'0x30d90b5b67be77e6e06f02dae9f0f2fcdad16e38854316ae8a7b4f5b4971f5e0::Market::buy_generic_with_ext',
+			arguments: [
+				tx.object(SOUFFL3_VERSION_OBJECT),
+				tx.object(SOUFFL3_EXTENSION_OBJECT),
+				tx.object(listingNonce),
+				tx.pure.u64(price),
+				tx.object(SOUFFL3_MARKETPLACE_OBJECT),
+				tx.object(coin),
+			],
+			typeArguments: [nftType, '0x2::sui::SUI'],
+		});
+
+		destroyZeroCoin({ tx, coin: coinToDestroy });
+	}
+}
+
+export function addSomisBuyTx({
+	tx,
+	sharedObjects,
+	nftTokenId,
+	nftType,
+	price,
+	coinToSplit,
+}: BuyTx) {
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(price)]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	tx.moveCall({
+		target:
+			'0xf0b0beb956e26bde50dbd6ac393026c4525aee3b194a9478f09748f7211b5a02::marketplace::buy_nft',
+		arguments: [
+			tx.object(sharedObjects?.marketplace),
+			tx.pure.address(nftTokenId),
+			tx.object(coin),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+}
+
+export async function addKeepsakeBuyTx({
+	tx,
+	sharedObjects,
+	buyer,
+	nftTokenId,
+	nftType,
+	price,
+	royalty,
+	transferPolicies,
+	coinToSplit,
+}: BuyTx) {
+	const { keepsakeRoyaltyStrategy } = sharedObjects;
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const [coin1, coin2] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [
+		tx.pure.u64(price),
+		tx.pure.u64((price * Number(royalty)) / 100 + price * Number(royalty) * 0.00005),
+	]);
+
+	if (!coin1 || !coin2) throw new Error('Coin could not be split');
+
+	const [balance] = tx.moveCall({
+		target: '0x2::coin::into_balance',
+		arguments: [tx.object(coin2)],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+
+	if (!balance) throw new Error('Coin into_balance failed');
+
+	const [transferRequest] = tx.moveCall({
+		target:
+			'0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::keepsake_marketplace::buy',
+		arguments: [
+			tx.object(KEEPSAKE_MARKETPLACE_OBJECT),
+			tx.object(KEEPSAKE_MARKETPLACE_KIOSK),
+			tx.pure.address(nftTokenId),
+			tx.object(coin1),
+		],
+		typeArguments: [nftType],
+	});
+
+	if (!transferRequest) throw new Error('Transfer request could not be created');
+
+	tx.moveCall({
+		target:
+			'0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::keepsake_royalties::confirm_transfer_with_balance',
+		arguments: [tx.object(keepsakeRoyaltyStrategy), tx.object(transferRequest), tx.object(balance)],
+		typeArguments: [nftType],
+	});
+
+	tx.moveCall({
+		target:
+			'0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::transfer_policy::confirm_request',
+		arguments: [tx.object(transferPolicyId), tx.object(transferRequest)],
+		typeArguments: [nftType],
+	});
+
+	const [balanceToTransfer] = tx.moveCall({
+		target: '0x2::coin::from_balance',
+		arguments: [tx.object(balance)],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+
+	if (!balanceToTransfer) throw new Error('Coin from_balance failed');
+
+	tx.transferObjects(
+		[tx.object(balanceToTransfer)],
+		tx.pure.address(addLeadingZerosAfter0x(buyer)),
+	);
+}
+
+export const addTocenBuyTx = ({ tx, nftTokenIds, nftType, price, coinToSplit }: TocenBuyTx) => {
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(price)]);
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	tx.moveCall({
+		target:
+			'0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::buy_cart',
+		arguments: [
+			tx.object(TOCEN_MARKETPLACE_OBJECT),
+			tx.pure(bcs.vector(bcs.Address).serialize(nftTokenIds)),
+			tx.object(coin),
+		],
+		typeArguments: [nftType],
+	});
+};
+
+export async function addTradePortBuyTxHandler(txData: BuyTx) {
+	// If origin byte collection, add origin byte buy tx
+	if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies)) {
+		const sharedObjects =
+			txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ??
+			(await getSharedObjects(txData?.nftType));
+		await addOriginByteBuyTx({ ...txData, sharedObjects });
+
+		return;
+	}
+
+	// If non kiosk listing (nonce starts with "0::")
+	if (txData?.listingNonce?.startsWith('0::')) {
+		await addTradePortBuyTx(txData);
+		return;
+	}
+
+	// If kiosk listing (nonce starts with "1::")
+	if (txData?.listingNonce?.startsWith('1::')) {
+		await kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: txData?.kioskClient,
+			kioskOwner: txData?.buyer,
+			kiosk: txData?.sellerKiosk,
+			shouldConvertToPersonalKiosk: true,
+			sharedKioskState: txData?.sharedKioskState,
+			async runCommands(kioskTx) {
+				await addKioskTradePortBuyTx({
+					...txData,
+					kioskTx,
+				});
+
+				// If XOCIETY Frontier collection, take NFT out of kiosk and transfer it back to user (buyer)
+				if (txData?.collectionId === XOCIETY_FRONTIER_COLLECTION_ID) {
+					const borrowedItem = kioskTx.take({
+						itemId: txData?.nftTokenId,
+						itemType: txData?.nftType,
+					});
+
+					txData?.tx.transferObjects(
+						[txData?.tx.object(borrowedItem as any)],
+						txData?.tx.pure.address(addLeadingZerosAfter0x(txData?.buyer)),
+					);
+				}
+			},
+		});
+
+		// If seller kiosk is associated with an NFT strategy, apply the strategy after the buy command
+		const chainState = await getCollectionChainState(txData.collectionId);
+		const nftStrategies = (chainState?.nft_strategies ?? {}) as Record<
+			string,
+			Record<string, unknown>
+		>;
+		const normalizedSellerKiosk = normalizeSuiObjectId(txData.sellerKiosk);
+		for (const [strategyFtType, strategyData] of Object.entries(nftStrategies)) {
+			const strategyKioskId = (strategyData as { kiosk_id: string }).kiosk_id ?? '0x0';
+			if (normalizeSuiObjectId(strategyKioskId) === normalizedSellerKiosk) {
+				await applyFtStrategy({
+					collectionId: txData.collectionId,
+					strategyFtType,
+					tx: txData.tx,
+					collectionChainState: chainState,
+				});
+				break;
+			}
+		}
+
+		return;
+	}
+
+	// Legacy contract logic below
+	if (txData.listingNonce?.startsWith('0x')) {
+		const response = await txData?.suiClient.getObject({
+			objectId: txData.listingNonce,
+			include: {},
+		});
+
+		if (response.object.type === NON_KIOSK_LISTING_NONCE_TYPE) {
+			const sharedObjects =
+				txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ??
+				(await getSharedObjects(txData?.nftType));
+			addLegacyTradePortBuyTx({ ...txData, sharedObjects });
+			return;
+		}
+	}
+
+	// If legacy kiosk listing
+	if (txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: txData?.kioskClient,
+			kioskOwner: txData?.buyer,
+			kiosk: txData?.sellerKiosk,
+			shouldConvertToPersonalKiosk: true,
+			sharedKioskState: txData?.sharedKioskState,
+			async runCommands(kioskTx) {
+				await addLegacyTradeportKioskBuyTx({
+					...txData,
+					kioskTx,
+				});
+			},
+		});
+	}
+
+	const sharedObjects =
+		txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ??
+		(await getSharedObjects(txData?.nftType));
+
+	// If legacy non kiosk listing
+	addLegacyTradePortBuyTx({ ...txData, sharedObjects });
+}
+
+export async function addHyperspaceBuyTxHandler(txData: BuyTx) {
+	if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies)) {
+		const sharedObjects =
+			txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ??
+			(await getSharedObjects(txData?.nftType));
+		await addOriginByteBuyTx({ ...txData, sharedObjects });
+
+		return;
+	}
+
+	return kioskTxWrapper({
+		tx: txData?.tx,
+		kioskClient: txData?.kioskClient,
+		kioskOwner: txData?.buyer,
+		kiosk: txData?.sellerKiosk,
+		shouldConvertToPersonalKiosk: true,
+		sharedKioskState: txData?.sharedKioskState,
+		async runCommands(kioskTx) {
+			await addHyperspaceKioskBuyTx({
+				...txData,
+				kioskTx,
+			});
+		},
+	});
+}
+
+export async function addBluemoveBuyTxHandler(txData: BuyTx) {
+	if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies)) {
+		const sharedObjects =
+			txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ??
+			(await getSharedObjects(txData?.nftType));
+		await addOriginByteBuyTx({ ...txData, sharedObjects });
+
+		return;
+	}
+
+	if (txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: txData?.kioskClient,
+			kioskOwner: txData?.buyer,
+			kiosk: txData?.sellerKiosk,
+			shouldConvertToPersonalKiosk: true,
+			sharedKioskState: txData?.sharedKioskState,
+			async runCommands(kioskTx) {
+				await addBluemoveKioskBuyTx({
+					...txData,
+					kioskTx,
+				});
+			},
+		});
+	}
+
+	addBluemoveBuyTx(txData);
+}
+
+export async function addClutchyBuyTxHandler(txData: BuyTx) {
+	const sharedObjects =
+		txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ??
+		(await getSharedObjects(txData?.nftType));
+	await addOriginByteBuyTx({ ...txData, sharedObjects });
+}
+
+export async function addSouffl3BuyTxHandler(txData: BuyTx) {
+	await addSouffl3BuyTx(txData);
+}
+
+export async function addSomisBuyTxHandler(txData: BuyTx) {
+	if (txData?.sharedObjects?.marketplace) {
+		addSomisBuyTx(txData);
+		return;
+	}
+
+	return addOriginByteBuyTx(txData);
+}
+
+export async function addKeepsakeBuyTxHandler(txData: BuyTx) {
+	const commission = await getCommissionByNftContractId(txData?.nftContractId);
+
+	await addKeepsakeBuyTx({
+		...txData,
+		royalty: commission?.royalty,
+	});
+}
+
+export function addTocenBuyTxHandler(txData: TocenBuyTx) {
+	addTocenBuyTx(txData);
+}