@tradeport/sui-trading-sdk 0.4.39 → 0.4.41

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tradeport/sui-trading-sdk",
   "license": "MIT",
-  "version": "0.4.39",
+  "version": "0.4.41",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -10,6 +10,7 @@
     "@babel/preset-env": "^7.23.3",
     "@changesets/cli": "^2.26.2",
     "@types/jest": "^29.5.10",
+    "@types/ms": "^2.1.0",
     "@types/node": "^20.10.0",
     "@typescript-eslint/eslint-plugin": "^6.13.1",
     "@typescript-eslint/parser": "^6.13.1",
@@ -27,12 +28,15 @@
     "typescript": "^5.3.2"
   },
   "dependencies": {
+    "@flowx-finance/sdk": "^1.13.5",
     "@mysten/kiosk": "^0.7.13",
     "@mysten/sui": "^1.17.0",
     "@mysten/sui.js": "^0.47.0",
     "@types/analytics-node": "^3.1.14",
     "analytics-node": "^6.2.0",
-    "graphql-request": "^6.1.0"
+    "bignumber.js": "^9.3.1",
+    "graphql-request": "^6.1.0",
+    "ms": "^2.1.3"
   },
   "publishConfig": {
     "access": "public",

package/src/SuiTradingClient.ts

@@ -66,6 +66,10 @@ import {
 	type WithdrawProfitsFromKiosks,
 } from './methods/withdrawProfitsFromKiosks/withdrawProfitsFromKiosks';
 import { addLeadingZerosAfter0x } from './utils/addLeadingZerosAfter0x';
+import {
+	type SponsorNftListing,
+	sponsorNftListing,
+} from './methods/sponsorNftListing/sponsorNftListing';
 
 type ApiConfig = {
 	apiUser: string;
@@ -484,6 +488,17 @@ class SuiTradingClient {
 	public async updateMultiBid(args: UpdateMultiBid) {
 		return updateMultiBid(args);
 	}
+
+	public async sponsorNftListing(args: SponsorNftListing) {
+		const context: RequestContext = {
+			apiUser: this.apiUser,
+			apiKey: this.apiKey,
+			suiClient: this.suiClient,
+			kioskClient: this.kioskClient,
+		};
+
+		return sponsorNftListing(args, context);
+	}
 }
 
 export default SuiTradingClient;

package/src/bigNumberConfig.ts

@@ -0,0 +1,10 @@
+import { BigNumber } from 'bignumber.js';
+
+BigNumber.set({
+	POW_PRECISION: 64,
+});
+
+export const ZERO = new BigNumber(0);
+export const ONE = new BigNumber(1);
+
+export default BigNumber;

package/src/constants.ts

@@ -3,10 +3,12 @@ export const MYSTEN_TRANFER_POLICY_RULES_PACKAGE_ID = '0x434b5bd8f6a7b05fede0ff4
 export const TRADEPORT_BENEFICIARY_ADDRESS = '0xbca3b5c01c8d1a93aed3a036feff45145518292dd3c1db1d67cc99a699a7b517';
 export const TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT = 0.03;
 export const TRADEPORT_THIRD_PARTY_FEE_DECIMAL_PERCENT = 0.005;
+export const TRADEPORT_LISTINGS_DEFAULT_COMMISSION_BPS = 300; // 3%
 export const TRADEPORT_LISTING_STORE = '0x47cba0b6309a12ce39f9306e28b899ed4b3698bce4f4911fd0c58ff2329a2ff6';
 export const TRADEPORT_BIDDING_STORE = '0x3d3b0c6e616fdc1a45b2b73d022bc085448e78bd729d28081c7a340abb33cba1';
 export const TRADEPORT_MARKETPLACE_OBJECT = '0xc5f87120e388b532ee774f7bac23347679f632a1f2d59f4ed2bbf2ffe5a61b6f';
-
+export const TRADEPORT_LISTINGS_PACKAGE = '0x318d9bbbbc65be1fe53f0de1af9fd93dcbcb8d57146aba9754cf7a3b55880f5c';
+export const TRADEPORT_LISTINGS_STORE = '0x90626186ce022b50109628f44ef09e183e55961972d9b1b79de53558103161ef';
 export const TRADEPORT_KIOSK_LISTING_STORE = '0xbff3161b047fb8b727883838c09b08afa9e0dd0f5488bde9e99e80643da9b9e0';
 export const TRADEPORT_KIOSK_TRANSFERS_STORE = '0xe0f61b6915d3fd4ec8bbe4618514e2152a82841605bfa00cde22ace434153a1b';
 export const TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK = '0xa677dab85a93bd8d6845b6cc7914f3bbb334fef7fbcbe0e997b5f75b5922d106';
@@ -21,6 +23,20 @@ export const TRADEPORT_MULTI_BID_PACKAGE = '0xd1dedf8379f1781469e95cb92eed7e155c
 export const TRADEPORT_MULTI_BID_PACKAGE_ORIGINAL = '0x53134eb544c5a0b5085e99efaf7eab13b28ad123de35d61f941f8c8c40b72033'; // V1
 export const TRADEPORT_MULTI_BID_STORE = '0x8aaed7e884343fb8b222c721d02eaac2c6ae2abbb4ddcdf16cb55cf8754ee860';
 
+export const DexConstants = {
+  commission: '0x24f5f2258ef80c0a3243088199faeb95ad50516ca1517dbd93be398d759057bb',
+  commissionManager: '0xd19a03d4ec3d12b0ce407b54eb676cc0f8e1403621deda77d9677bfcb9d738c1',
+  poolsToExclude: [
+    '0x3addbbc82866c0bbd93e51b6e2d75c0a4faaf270cc0e281d8f4de5df48bebfa4',
+    '0x19d614f421046cae90f5a3a976816063478f648087a12adc74e90ebd54dfaf19',
+    '0x514c74e28a9720366abc4a65a5688f47c72e784dbf035844d3f59059bfaed056',
+    '0x0854de4e9d64716b757b2f6f22258467f59cc1b4bc0cc64c70086549faaddedf',
+  ],
+};
+
+export const TRADEPORT_SPONSOR_USDC_FEE_AMOUNT_PER_PERIOD = 20000000; // 20 USDC
+export const USDC_COIN_TYPE = '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC';
+
 export const COLLECTION_IDS_WITH_ZERO_COMMISSION = [
 	'',
 ];

package/src/graphql/queries/fetchNftCollectionChainState.ts

@@ -0,0 +1,12 @@
+import { gql } from 'graphql-request';
+
+export const fetchNftCollectionChainState = gql`
+	query fetchNftCollectionChainState($nftTokenId: String!) {
+		nfts(where: { token_id: { _eq: $nftTokenId } }) {
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;

package/src/helpers/calculateRoyaltyFee.ts

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

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/kiosk/preProcessSharedBulkBuyingData.ts

@@ -63,16 +63,18 @@ export const preProcessSharedBulkBuyingData = async ({
 			continue;
 		}
 
-		const tradeportKioskListings = listingsByNftType[nftType]?.filter(
+		const tradeportLegacyKioskListings = listingsByNftType[nftType]?.filter(
 			(listing: any) =>
 				listing.market_name === 'tradeport' &&
+				!listing.nonce?.startsWith('0::') &&
+				!listing.nonce?.startsWith('1::') &&
 				listing.price &&
 				listing.listed &&
 				!(listing?.nonce && isOriginByteCollection(transferPolicies)) &&
 				listing.nft?.chain_state?.kiosk_id,
 		);
 
-		if (tradeportKioskListings.length === 0) {
+		if (tradeportLegacyKioskListings.length === 0) {
 			continue;
 		}
 
@@ -87,14 +89,13 @@ export const preProcessSharedBulkBuyingData = async ({
 		const transferPolicyToResolve = transferPoliciesToResolve.at(0);
 
 		const royaltyRuleToResolve = transferPolicyToResolve.rules.find(
-			(policy: any) =>
-				policy.moduleName === 'royalty_rule' || policy.moduleName === 'kiosk_royalty_rule',
+			(rule: any) => rule.moduleName === 'royalty_rule' || rule.moduleName === 'kiosk_royalty_rule',
 		);
 
 		if (royaltyRuleToResolve?.rulePackageId && royaltyRuleToResolve?.moduleName) {
 			// for each tp kiosk listing, create fee_amount txs and dev inspect the tx block to get the royalty fee amounts and store them in shared data
 			const feeTx = new Transaction();
-			for (const listing of tradeportKioskListings) {
+			for (const listing of tradeportLegacyKioskListings) {
 				feeTx.moveCall({
 					target: `${royaltyRuleToResolve.rulePackageId}::${royaltyRuleToResolve.moduleName}::fee_amount`,
 					arguments: [feeTx.object(transferPolicyToResolve?.id), feeTx.pure.u64(listing.price)],
@@ -118,7 +119,7 @@ export const preProcessSharedBulkBuyingData = async ({
 				}
 
 				sharedBulkBuyingDataByNftType[nftType].royaltyFeeAmountsByListingId[
-					tradeportKioskListings[i].id
+					tradeportLegacyKioskListings[i].id
 				] = feeAmount;
 			}
 		}
@@ -126,8 +127,8 @@ export const preProcessSharedBulkBuyingData = async ({
 		// for each tp kiosk listing, pre-fetch commission fee amounts in batches and store them in shared data
 		const batchSize = 10;
 		const commissionResults: Array<{ listingId: string; commission: number }> = [];
-		for (let i = 0; i < tradeportKioskListings.length; i += batchSize) {
-			const batch = tradeportKioskListings.slice(i, i + batchSize);
+		for (let i = 0; i < tradeportLegacyKioskListings.length; i += batchSize) {
+			const batch = tradeportLegacyKioskListings.slice(i, i + batchSize);
 			const batchPromises = batch.map(async (listing: any) => {
 				const response = await suiClient.getDynamicFieldObject({
 					parentId: TRADEPORT_KIOSK_LISTING_STORE,

package/src/helpers/swap.ts

@@ -0,0 +1,197 @@
+import { AggregatorQuoter, CoinProvider, Protocol, TradeBuilder } from '@flowx-finance/sdk';
+import { type SuiClient } from '@mysten/sui/client';
+import {
+	coinWithBalance,
+	Transaction,
+	type TransactionObjectArgument,
+} from '@mysten/sui/transactions';
+import { normalizeStructTag, normalizeSuiAddress } from '@mysten/sui/utils';
+import ms, { type StringValue } from 'ms';
+import { bcs } from '@mysten/sui/bcs';
+import BigNumber from '../bigNumberConfig';
+import { DexConstants } from '../constants';
+import { ZERO } from '../bigNumberConfig';
+import { toDecimalValue, toPureValue } from '../utils/pureValues';
+import { destroyZeroCoin } from './destroyZeroCoin';
+
+const aggregatorQuoter = new AggregatorQuoter('mainnet');
+
+const suiCoinType = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+
+export interface SwapOptions {
+	coinInAmount: string;
+	coinInType?: string;
+	coinOutType?: string;
+	coinOutAmount?: string;
+	slippage?: number;
+	ttl?: StringValue;
+	excludeSources?: Protocol[];
+	amountToSplitFromSuiBalance?: string;
+	rewardNftType?: string;
+}
+
+export async function createSwapTransaction({
+	suiClient,
+	walletAddress,
+	options,
+}: {
+	suiClient: SuiClient;
+	walletAddress: string;
+	options: {
+		transaction: Transaction;
+		coinInType: string;
+		coinInAmount: BigNumber;
+		coinOutType?: string;
+		slippage?: number;
+		ttl?: StringValue;
+		excludeSources?: Protocol[];
+		amountToSplitFromSuiBalance?: bigint;
+		rewardNftType?: string;
+	};
+}): Promise<{
+	transaction: Transaction;
+	coinOut: TransactionObjectArgument;
+}> {
+	const tx = options?.transaction ?? new Transaction();
+	tx.setSender(normalizeSuiAddress(walletAddress));
+
+	const {
+		coinInType,
+		coinInAmount = ZERO,
+		coinOutType,
+		slippage = 1,
+		ttl = '15m',
+		excludeSources = [Protocol.STEAMM, ...DexConstants.poolsToExclude],
+		rewardNftType,
+	} = options ?? {};
+
+	if (
+		normalizeStructTag(coinOutType) === suiCoinType &&
+		normalizeStructTag(coinInType) === suiCoinType
+	) {
+		const [coin] = tx.splitCoins(tx.gas, [coinInAmount.toFixed()]);
+		return {
+			transaction: tx,
+			coinOut: coin,
+		};
+	}
+
+	const amountInSwap = coinInAmount.minus(coinInAmount.div(100).toFixed(0));
+	const commissionAmount = coinInAmount.div(100).toFixed(0);
+
+	const { routes } = await aggregatorQuoter.getRoutes({
+		tokenIn: coinInType,
+		tokenOut: coinOutType ?? suiCoinType,
+		amountIn: amountInSwap.toFixed(),
+		excludeSources: excludeSources as Protocol[],
+	});
+
+	const tradeBuilder = new TradeBuilder('mainnet', routes);
+
+	const trade = tradeBuilder
+		.sender(normalizeSuiAddress(walletAddress))
+		.slippage(slippage)
+		.deadline(Date.now() + ms(ttl))
+		.build();
+
+	let coinIn: TransactionObjectArgument;
+
+	if (normalizeStructTag(coinInType) === suiCoinType) {
+		[coinIn] = tx.splitCoins(tx.gas, [
+			tx.pure.u64((BigInt(amountInSwap.toFixed()) + BigInt(commissionAmount)).toString()),
+		]);
+	} else {
+		coinIn = coinWithBalance({
+			balance: BigInt(amountInSwap.toFixed()) + BigInt(commissionAmount),
+			type: coinInType,
+		})(tx);
+	}
+
+	const [commissionCoin] = tx.splitCoins(coinIn, [tx.pure.u64(commissionAmount.toString())]);
+
+	tx.moveCall({
+		target: `${DexConstants.commission}::commission::pay`,
+		arguments: [
+			tx.object(DexConstants.commissionManager),
+			tx.pure.string('swap'),
+			tx.object(commissionCoin),
+			tx.pure(bcs.option(bcs.String).serialize(rewardNftType).toBytes()),
+		],
+		typeArguments: [coinInType],
+	});
+
+	const coinOut = await trade.swap({ client: suiClient, tx, coinIn });
+
+	if (!coinOut) {
+		throw new Error('Swap did not return a valid coin out.');
+	}
+
+	if (coinOut && options?.amountToSplitFromSuiBalance > 0n) {
+		mergeSwapCoinWithSuiBalance(tx, coinOut, options?.amountToSplitFromSuiBalance);
+	}
+
+	return { transaction: tx, coinOut };
+}
+
+function mergeSwapCoinWithSuiBalance(
+	transaction: Transaction,
+	coinToMergeInto: TransactionObjectArgument | undefined,
+	amountToSplitFromSuiBalance: bigint | undefined,
+): void {
+	if (coinToMergeInto && amountToSplitFromSuiBalance > 0n) {
+		const [coinFromSuiBalance] = transaction.splitCoins(transaction.gas, [
+			transaction.pure.u64(amountToSplitFromSuiBalance),
+		]);
+		transaction.mergeCoins(coinToMergeInto, [coinFromSuiBalance]);
+	}
+}
+
+export function transferBackExtraSwappedCoin(
+	transaction: Transaction,
+	swapResultCoin: TransactionObjectArgument | undefined,
+	walletAddress: string,
+): void {
+	if (swapResultCoin) {
+		transaction.transferObjects([swapResultCoin], walletAddress);
+	}
+}
+
+export async function calculateSwapInputAmountWithSlippage({
+	coinInType,
+	coinOutType,
+	coinOutAmount,
+	slippage = 0,
+}: {
+	coinInType: string;
+	coinOutType: string;
+	coinOutAmount: string | number;
+	slippage?: number;
+}): Promise<BigNumber> {
+	if (coinInType === coinOutType) {
+		return new BigNumber(coinOutAmount);
+	}
+
+	const provider = new CoinProvider('mainnet');
+
+	const coinQueryResult = await provider.getCoins({
+		limit: 2,
+		coinTypes: [coinInType, coinOutType],
+	});
+
+	const coinIn = coinQueryResult[0];
+	const coinOut = coinQueryResult[1];
+
+	const exchangeRate = new BigNumber(coinOut.derivedPriceInUSD ?? 0)?.gt(0)
+		? new BigNumber(coinIn?.derivedPriceInUSD ?? 1)?.div(coinOut?.derivedPriceInUSD ?? 1)
+		: new BigNumber(0);
+
+	const amountSell = toDecimalValue(coinOutAmount.toString(), coinOut?.decimals).div(exchangeRate);
+
+	const slippageMultiplier = 1 + parseInt(slippage.toString() || '0', 10) / 1000000;
+
+	const amountWithSlippage = amountSell.times(slippageMultiplier);
+
+	const coinInAmount = toPureValue(amountWithSlippage, coinIn?.decimals);
+
+	return coinInAmount;
+}

package/src/helpers/validateMinFloorPrice.ts

@@ -0,0 +1,22 @@
+import { getNativeKioskTransferPolicies } from './kiosk/getNativeKioskTransferPolicies';
+
+interface ValidateMinFloorPriceArgs {
+	transferPolicies: any;
+	listPrice: number;
+}
+
+export function validateMinFloorPrice({ transferPolicies, listPrice }: ValidateMinFloorPriceArgs) {
+	const transferPolicy = getNativeKioskTransferPolicies(transferPolicies)?.at(0);
+	const minFloorPrice = transferPolicy?.rules?.filter(
+		(rule: any) => rule?.type === 'floor_price_rule',
+	)?.[0]?.floor_price;
+
+	if (minFloorPrice) {
+		if (listPrice < minFloorPrice) {
+			const formattedMinFloorPrice = Number(minFloorPrice) / 1000000000;
+			throw new Error(
+				`NFT Transfer Policy has a miminum floor price rule. Item cannot be listed for less than ${formattedMinFloorPrice} SUI`,
+			);
+		}
+	}
+}

package/src/methods/buyListings/addBuyListingTxs.ts

@@ -14,8 +14,11 @@ import {
 	SOUFFL3_MARKETPLACE_OBJECT,
 	SOUFFL3_VERSION_OBJECT,
 	TOCEN_MARKETPLACE_OBJECT,
+	TRADEPORT_LISTINGS_DEFAULT_COMMISSION_BPS,
 	TRADEPORT_KIOSK_LISTING_STORE,
 	TRADEPORT_LISTING_STORE,
+	TRADEPORT_LISTINGS_PACKAGE,
+	TRADEPORT_LISTINGS_STORE,
 } from '../../constants';
 import { getCommissionByNftContractId } from '../../graphql/queries/getCommissionByListingId';
 import { destroyZeroCoin } from '../../helpers/destroyZeroCoin';
@@ -31,8 +34,10 @@ import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCol
 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';
 
-export function addTradePortBuyTx({
+export function addLegacyTradePortBuyTx({
 	tx,
 	nftType,
 	listingNonce,
@@ -73,7 +78,7 @@ export function addTradePortBuyTx({
 	destroyZeroCoin({ tx, coin });
 }
 
-export const addTradeportKioskBuyTx = async ({
+export const addLegacyTradeportKioskBuyTx = async ({
 	tx,
 	transferPolicies,
 	kioskTx,
@@ -151,6 +156,78 @@ export const addTradeportKioskBuyTx = async ({
 	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_listing_without_transfer_policy`,
+		arguments: [tx.object(TRADEPORT_LISTINGS_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,
+}: 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_listing_with_transfer_policy`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(sellerKiosk),
+			tx.object('value' in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk),
+			tx.object('value' in kioskTx.kioskCap ? kioskTx.kioskCap.value : kioskTx.kioskCap),
+			tx.pure.id(nftTokenId),
+			tx.object(coin),
+			tx.object(transferPolicyId),
+		],
+		typeArguments: [nftType],
+	});
+
+	tx.moveCall({
+		target: '0x2::transfer_policy::confirm_request',
+		arguments: [tx.object(transferPolicyId), transferRequest],
+		typeArguments: [nftType],
+	});
+
+	destroyZeroCoin({ tx, coin });
+}
+
 export async function addOriginByteBuyTx({
 	tx,
 	sharedObjects,
@@ -494,6 +571,7 @@ export const addTocenBuyTx = ({ tx, nftTokenIds, nftType, price, coinToSplit }:
 };
 
 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 ??
@@ -503,6 +581,31 @@ export async function addTradePortBuyTxHandler(txData: BuyTx) {
 		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::')) {
+		return 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,
+				});
+			},
+		});
+	}
+
+	// Legacy contract logic below
 	if (txData.listingNonce?.startsWith('0x')) {
 		const response = await txData?.suiClient.getObject({
 			id: txData.listingNonce,
@@ -516,11 +619,12 @@ export async function addTradePortBuyTxHandler(txData: BuyTx) {
 			const sharedObjects =
 				txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ??
 				(await getSharedObjects(txData?.nftType));
-			addTradePortBuyTx({ ...txData, sharedObjects });
+			addLegacyTradePortBuyTx({ ...txData, sharedObjects });
 			return;
 		}
 	}
 
+	// If legacy kiosk listing
 	if (txData?.sellerKiosk) {
 		return kioskTxWrapper({
 			tx: txData?.tx,
@@ -530,7 +634,7 @@ export async function addTradePortBuyTxHandler(txData: BuyTx) {
 			shouldConvertToPersonalKiosk: true,
 			sharedKioskState: txData?.sharedKioskState,
 			async runCommands(kioskTx) {
-				await addTradeportKioskBuyTx({
+				await addLegacyTradeportKioskBuyTx({
 					...txData,
 					kioskTx,
 				});
@@ -541,7 +645,9 @@ export async function addTradePortBuyTxHandler(txData: BuyTx) {
 	const sharedObjects =
 		txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ??
 		(await getSharedObjects(txData?.nftType));
-	addTradePortBuyTx({ ...txData, sharedObjects });
+
+	// If legacy non kiosk listing
+	addLegacyTradePortBuyTx({ ...txData, sharedObjects });
 }
 
 export async function addHyperspaceBuyTxHandler(txData: BuyTx) {

package/src/methods/buyLocks/buyLocks.ts

@@ -41,7 +41,7 @@ export async function buyLocks(
 			}),
 		);
 
-		const royalty = calculateRoyaltyFee(transferPolicy.rules, BigInt(lock.maker_price));
+		const royalty = calculateRoyaltyFee(transferPolicy.rules, new BigNumber(lock.maker_price));
 
 		const premiumAmount = calculatePremium(lock.maker_price);
 
@@ -56,7 +56,7 @@ export async function buyLocks(
 				tx.pure.id(lock.lock_id),
 				tx.pure.u64(lock.maker_price),
 				tx.pure.u64(marketplaceFee),
-				tx.pure.u64(royalty),
+				tx.pure.u64(royalty.toNumber()),
 				tx.pure.u64(lock.expire_in),
 				premium,
 			],

package/src/methods/createLongLocks/createLongLocks.ts

@@ -63,7 +63,7 @@ export async function createLongLocks(
 			throw new Error(`Missing transfer policy for ${nftType}`);
 		}
 
-		const royalty = calculateRoyaltyFee(transferPolicy.rules, BigInt(argNft.priceInMist));
+		const royalty = calculateRoyaltyFee(transferPolicy.rules, new BigNumber(argNft.priceInMist));
 
 		await kioskTxWrapper({
 			tx,
@@ -88,7 +88,7 @@ export async function createLongLocks(
 								}),
 							),
 						),
-						tx.pure.u64(royalty),
+						tx.pure.u64(royalty.toNumber()),
 						tx.pure.u64(premium),
 						tx.pure.u64(expireIn),
 					],

package/src/methods/createShortLocks/createShortLocks.ts

@@ -42,10 +42,10 @@ export async function createShortLocks(
 			}),
 		);
 
-		const royalty = calculateRoyaltyFee(transferPolicy.rules, BigInt(argNft.priceInMist));
+		const royalty = calculateRoyaltyFee(transferPolicy.rules, new BigNumber(argNft.priceInMist));
 
 		const [deposit] = tx.splitCoins(tx.gas, [
-			BigInt(argNft.priceInMist) + royalty + marketplaceFee,
+			new BigNumber(argNft.priceInMist).plus(royalty).plus(marketplaceFee).toNumber(),
 		]);
 
 		tx.moveCall({
@@ -55,7 +55,7 @@ export async function createShortLocks(
 				tx.object(TRADEPORT_PRICE_LOCK_STORE),
 				tx.pure.u64(BigInt(argNft.priceInMist)),
 				tx.pure.u64(marketplaceFee),
-				tx.pure.u64(royalty),
+				tx.pure.u64(royalty.toNumber()),
 				tx.pure.u64(premium),
 				tx.pure.u64(expireIn),
 				deposit,