@tradeport/sui-trading-sdk 0.4.39 → 0.4.40

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tradeport/sui-trading-sdk",
   "license": "MIT",
-  "version": "0.4.39",
+  "version": "0.4.40",
   "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,14 @@
     "typescript": "^5.3.2"
   },
   "dependencies": {
-    "@mysten/kiosk": "^0.7.13",
-    "@mysten/sui": "^1.17.0",
+    "@flowx-finance/sdk": "^1.13.5",
+    "@mysten/kiosk": "^0.12.26",
+    "@mysten/sui": "^1.39.1",
     "@mysten/sui.js": "^0.47.0",
     "@types/analytics-node": "^3.1.14",
     "analytics-node": "^6.2.0",
-    "graphql-request": "^6.1.0"
+    "graphql-request": "^6.1.0",
+    "ms": "^2.1.3"
   },
   "publishConfig": {
     "access": "public",

package/src/SuiTradingClient.ts

@@ -105,7 +105,12 @@ class SuiTradingClient {
 		// trackMethodCall({ apiUser, apiKey, event: 'INITIALIZE_CLIENT' });
 	}
 
-	public async buyListings({ listingIds, walletAddress, tx }: BuyListings): Promise<Transaction> {
+	public async buyListings({
+		listingIds,
+		walletAddress,
+		tx,
+		swapAndPayOptions,
+	}: BuyListings): Promise<Transaction> {
 		const context: RequestContext = {
 			apiUser: this.apiUser,
 			apiKey: this.apiKey,
@@ -113,7 +118,7 @@ class SuiTradingClient {
 			kioskClient: this.kioskClient,
 		};
 
-		return buyListings({ listingIds, walletAddress, tx }, context);
+		return buyListings({ listingIds, walletAddress, tx, swapAndPayOptions }, context);
 	}
 
 	public async listNfts({ nfts, walletAddress }: ListNfts) {
@@ -180,6 +185,7 @@ class SuiTradingClient {
 		multiBidChainId,
 		expireAt,
 		tx,
+		swapAndPayOptions,
 	}: PlaceCollectionBid): Promise<Transaction> {
 		const context: RequestContext = {
 			apiUser: this.apiUser,
@@ -202,6 +208,7 @@ class SuiTradingClient {
 				multiBidId,
 				multiBidChainId,
 				tx,
+				swapAndPayOptions,
 			},
 			context,
 		);
@@ -474,7 +481,14 @@ class SuiTradingClient {
 	}
 
 	public async createMultiBid(args: CreateMultiBid) {
-		return createMultiBid(args);
+		const context: RequestContext = {
+			apiUser: this.apiUser,
+			apiKey: this.apiKey,
+			suiClient: this.suiClient,
+			kioskClient: this.kioskClient,
+		};
+
+		return createMultiBid(args, context);
 	}
 
 	public async cancelMultiBid(args: CancelMultiBid) {
@@ -482,7 +496,7 @@ class SuiTradingClient {
 	}
 
 	public async updateMultiBid(args: UpdateMultiBid) {
-		return updateMultiBid(args);
+		return updateMultiBid({ ...args, suiClient: this.suiClient });
 	}
 }
 

package/src/helpers/kiosk/getKioskIdFromKioskTx.ts

@@ -17,5 +17,5 @@ export const getKioskIdFromKioskTx = ({
 						throw new Error('Invalid kiosk transaction structure');
 					})();
 
-	return kioskId;
+	return kioskId as string;
 };

package/src/helpers/kiosk/kioskTxWrapper.ts

@@ -105,7 +105,7 @@ export const kioskTxWrapper = async ({
 			})
 		).personalCap.id;
 		kioskTx = new KioskTransaction({
-			transactionBlock: tx as any,
+			transaction: tx as any,
 			kioskClient,
 			cap: {
 				isPersonal: true,
@@ -124,7 +124,7 @@ export const kioskTxWrapper = async ({
 			})
 		).ownerCap?.id;
 		kioskTx = new KioskTransaction({
-			transactionBlock: tx as any,
+			transaction: tx as any,
 			kioskClient,
 			cap: {
 				isPersonal: false,
@@ -136,7 +136,7 @@ export const kioskTxWrapper = async ({
 		});
 	} else {
 		// creating new personal kiosk
-		kioskTx = new KioskTransaction({ transactionBlock: tx as any, kioskClient });
+		kioskTx = new KioskTransaction({ transaction: tx as any, kioskClient });
 		kioskTx.createPersonal(true);
 	}
 

package/src/helpers/kiosk/lockNftInsideKioskIfNotLocked.ts

@@ -54,7 +54,7 @@ export const lockNftInsideKioskIfNotLocked = async ({
 		}
 
 		kioskTx.lock({
-			itemId: takenNftId ?? nftTokenId,
+			item: (takenNftId as string) ?? nftTokenId,
 			itemType: nftType,
 			policy: transferPolicyId,
 		});

package/src/helpers/kiosk/resolveRoyaltyRule.ts

@@ -4,6 +4,7 @@ import {
 	type TransactionArgument,
 	type TransactionObjectInput,
 } from '@mysten/sui/transactions';
+import { mergeSwapCoinWithSuiBalance } from '../swap/swap';
 import { getKioskCollectionRoyaltyFeeAmount } from './getKioskCollectionRoyaltyFeeAmount';
 
 type Args = {
@@ -18,6 +19,7 @@ type Args = {
 	price: string;
 	coinToSplit?: any;
 	royaltyFeeAmount?: bigint;
+	amountToSplitFromSuiBalance?: bigint;
 };
 
 export async function resolveRoyaltyRule({
@@ -32,6 +34,7 @@ export async function resolveRoyaltyRule({
 	price,
 	coinToSplit,
 	royaltyFeeAmount,
+	amountToSplitFromSuiBalance,
 }: Args) {
 	let feeAmount: bigint | TransactionArgument | undefined = royaltyFeeAmount;
 	if (!feeAmount) {
@@ -47,6 +50,8 @@ export async function resolveRoyaltyRule({
 		});
 	}
 
+	mergeSwapCoinWithSuiBalance(tx, coinToSplit, amountToSplitFromSuiBalance);
+
 	const feeCoin = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [feeAmount]);
 
 	tx.moveCall({

package/src/helpers/kiosk/resolveTransferPolicies.ts

@@ -37,6 +37,7 @@ type Props = {
 	beforeResolveKioskTransferRequest?: (transferRequest: any) => void | Promise<void>;
 	transferPoliciesToResolve?: any[];
 	royaltyFeeAmount?: bigint;
+	amountToSplitFromSuiBalance?: bigint;
 };
 
 export const resolveTransferPolicies = async ({
@@ -58,6 +59,7 @@ export const resolveTransferPolicies = async ({
 	beforeResolveKioskTransferRequest,
 	transferPoliciesToResolve,
 	royaltyFeeAmount,
+	amountToSplitFromSuiBalance,
 }: Props) => {
 	const policies =
 		transferPoliciesToResolve ??
@@ -111,6 +113,7 @@ export const resolveTransferPolicies = async ({
 						price,
 						coinToSplit,
 						royaltyFeeAmount,
+						amountToSplitFromSuiBalance,
 					});
 					break;
 				case 'floor_price_rule':

package/src/helpers/kiosk/takeLockedNftFromKiosk.ts

@@ -1,6 +1,6 @@
 import { type KioskClient, type KioskTransaction, type TransferPolicy } from '@mysten/kiosk';
 import { type SuiClient } from '@mysten/sui/client';
-import { type Transaction } from '@mysten/sui/transactions';
+import { type Transaction, type TransactionObjectInput } from '@mysten/sui/transactions';
 import { getNativeKioskTransferPolicies } from './getNativeKioskTransferPolicies';
 import { resolveTransferPolicies } from './resolveTransferPolicies';
 
@@ -36,8 +36,14 @@ export const takeLockedNftFromKiosk = async ({
 	const [purchase_cap] = tx.moveCall({
 		target: '0x2::kiosk::list_with_purchase_cap',
 		arguments: [
-			tx.object('value' in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk),
-			tx.object('value' in kioskTx.kioskCap ? kioskTx.kioskCap.value : kioskTx.kioskCap),
+			tx.object(
+				('value' in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk) as TransactionObjectInput,
+			),
+			tx.object(
+				('value' in kioskTx.kioskCap
+					? kioskTx.kioskCap.value
+					: kioskTx.kioskCap) as TransactionObjectInput,
+			),
 			tx.pure.address(nftTokenId),
 			tx.pure.u64(0),
 		],
@@ -53,7 +59,9 @@ export const takeLockedNftFromKiosk = async ({
 	const [nft, transferRequest] = tx.moveCall({
 		target: '0x2::kiosk::purchase_with_cap',
 		arguments: [
-			tx.object('value' in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk),
+			tx.object(
+				('value' in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk) as TransactionObjectInput,
+			),
 			purchase_cap,
 			zeroCoin,
 		],

package/src/helpers/swap/swap.ts

@@ -0,0 +1,147 @@
+import { AggregatorQuoter, Protocol, TradeBuilder } from '@flowx-finance/sdk';
+import { type SuiClient } from '@mysten/sui/client';
+import { Transaction, type TransactionObjectArgument } from '@mysten/sui/transactions';
+import { normalizeStructTag, normalizeSuiAddress } from '@mysten/sui/utils';
+import ms, { type StringValue } from 'ms';
+
+const aggregatorQuoter = new AggregatorQuoter('mainnet');
+
+const suiCointType = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+
+export interface SwapAndPayOptions {
+	coinType?: string;
+	coinAmount?: string;
+	slippage?: number;
+	ttl?: StringValue;
+	excludeSources?: Protocol[];
+	amountToSplitFromSuiBalance?: string;
+}
+
+export async function createBuyTransaction(
+	client: SuiClient,
+	walletAddress: string,
+	suiAmount: bigint,
+	options?: {
+		transaction: Transaction;
+		coinType?: string;
+		coinAmount?: bigint;
+		slippage?: number;
+		ttl?: StringValue;
+		excludeSources?: Protocol[];
+	},
+): Promise<{
+	transaction: Transaction;
+	suiCoin: TransactionObjectArgument;
+}> {
+	const transaction = options?.transaction ?? new Transaction();
+	transaction.setSender(normalizeSuiAddress(walletAddress));
+	const {
+		coinType,
+		coinAmount = 0n,
+		slippage = 1,
+		ttl = '15m',
+		excludeSources = [Protocol.STEAMM],
+	} = options ?? {};
+	if (!coinType || normalizeStructTag(coinType) === suiCointType) {
+		const [coin] = transaction.splitCoins(transaction.gas, [suiAmount]);
+		return {
+			transaction,
+			suiCoin: coin,
+		};
+	}
+
+	const { routes } = await aggregatorQuoter.getRoutes({
+		tokenIn: coinType,
+		tokenOut: suiCointType,
+		amountIn: coinAmount.toString(),
+		excludeSources,
+	});
+
+	const tradeBuilder = new TradeBuilder('mainnet', routes);
+
+	const trade = tradeBuilder
+		.sender(normalizeSuiAddress(walletAddress))
+		.slippage(slippage)
+		.deadline(Date.now() + ms(ttl))
+		.build();
+
+	const swappedSuiCoin = await trade.swap({
+		client: client as any,
+		tx: transaction as any,
+	});
+
+	if (!swappedSuiCoin) {
+		throw new Error('Swap did not return a valid SUI coin.');
+	}
+
+	return { transaction, suiCoin: swappedSuiCoin };
+}
+
+/**
+ * Handles swap setup for transactions that need to convert tokens to SUI
+ * @returns Updated transaction and the swapped coin (if swap was needed)
+ */
+export async function handleSwapSetup(
+	client: SuiClient,
+	walletAddress: string,
+	transaction: Transaction,
+	swapAndPayOptions?: SwapAndPayOptions,
+): Promise<{
+	transaction: Transaction;
+	swapResultCoin?: TransactionObjectArgument;
+}> {
+	if (!swapAndPayOptions?.coinType || !swapAndPayOptions?.coinAmount) {
+		return { transaction };
+	}
+
+	const { transaction: updatedTx, suiCoin } = await createBuyTransaction(
+		client,
+		walletAddress,
+		BigInt(swapAndPayOptions.coinAmount),
+		{
+			transaction,
+			coinType: swapAndPayOptions.coinType,
+			coinAmount: BigInt(swapAndPayOptions.coinAmount),
+			slippage: swapAndPayOptions.slippage,
+			ttl: swapAndPayOptions.ttl,
+			excludeSources: swapAndPayOptions.excludeSources,
+		},
+	);
+
+	return {
+		transaction: updatedTx,
+		swapResultCoin: suiCoin,
+	};
+}
+
+/**
+ * Handles cleanup after swap by transferring remaining coins back to wallet
+ */
+export function handleSwapCleanup(
+	transaction: Transaction,
+	swapResultCoin: TransactionObjectArgument | undefined,
+	walletAddress: string,
+): void {
+	if (swapResultCoin) {
+		transaction.transferObjects([swapResultCoin], walletAddress);
+	}
+}
+
+/**
+ * Merges a coin with an amount split from the gas balance
+ * @param transaction - The transaction to add the split and merge operations to
+ * @param coinToMergeInto - The coin to merge the gas balance into (optional)
+ * @param amountToSplitFromGas - The amount to split from the gas balance
+ */
+export function mergeSwapCoinWithSuiBalance(
+	transaction: Transaction,
+	coinToMergeInto: TransactionObjectArgument | undefined,
+	amountToSplitFromGas: bigint | undefined,
+): void {
+	if (coinToMergeInto && amountToSplitFromGas && amountToSplitFromGas > 0n) {
+		const [coinFromSuiBalance] = transaction.splitCoins(transaction.gas, [
+			transaction.pure.u64(amountToSplitFromGas),
+		]);
+		transaction.mergeCoins(coinToMergeInto, [coinFromSuiBalance]);
+	}
+}

package/src/methods/acceptCollectionBid/acceptCollectionBid.ts

@@ -185,5 +185,5 @@ export const acceptCollectionBid = async (
 	// 	});
 	// }
 
-	return Transaction.from(tx);
+	return tx instanceof Transaction ? tx : Transaction.from(tx);
 };

package/src/methods/acceptNftBids/acceptNftBids.ts

@@ -170,5 +170,5 @@ export const acceptNftBids = async (
 	// 	});
 	// }
 
-	return Transaction.from(tx);
+	return tx instanceof Transaction ? tx : Transaction.from(tx);
 };

package/src/methods/buyListings/addBuyListingTxs.ts

@@ -29,6 +29,7 @@ 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 { mergeSwapCoinWithSuiBalance } from '../../helpers/swap/swap';
 import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
 import { type BuyTx, type TocenBuyTx } from './buyListings';
 
@@ -89,6 +90,7 @@ export const addTradeportKioskBuyTx = async ({
 	beforeResolveKioskTransferRequest,
 	sharedBulkBuyingDataByNftType,
 	collectionId,
+	amountToSplitFromSuiBalance,
 }: BuyTx) => {
 	let commissionFeeAmount: number =
 		sharedBulkBuyingDataByNftType?.[nftType]?.commissionFeeAmountsByListingId?.[listingId] ?? 0;
@@ -111,6 +113,8 @@ export const addTradeportKioskBuyTx = async ({
 		commissionFeeAmount = getMarketFeePrice({ price, collectionId });
 	}
 
+	mergeSwapCoinWithSuiBalance(tx, coinToSplit, amountToSplitFromSuiBalance);
+
 	const coin = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [
 		tx.pure.u64(price + commissionFeeAmount),
 	]);
@@ -146,6 +150,7 @@ export const addTradeportKioskBuyTx = async ({
 		transferPoliciesToResolve: sharedBulkBuyingDataByNftType?.[nftType]?.transferPoliciesToResolve,
 		royaltyFeeAmount:
 			sharedBulkBuyingDataByNftType?.[nftType]?.royaltyFeeAmountsByListingId?.[listingId],
+		amountToSplitFromSuiBalance,
 	});
 
 	destroyZeroCoin({ tx, coin });

package/src/methods/buyListings/buyListings.ts

@@ -10,13 +10,17 @@ import { gqlChainRequest } from '../../graphql/gqlChainRequest';
 import { fetchListingsById } from '../../graphql/queries/fetchListingsById';
 import { addThirdPartyTxFee } from '../../helpers/addThirdPartyTxFee';
 import { deserializeOrCreateTxBlock } from '../../helpers/deserializeOrCreateTxBlock';
-import { extractSwapResultCoinFromTxBlock } from '../../helpers/extractSwapResultCoin';
 import { getNftType } from '../../helpers/getNftType';
 import {
 	preProcessSharedBulkBuyingData,
 	type SharedBulkBuyingDataByNftType,
 } from '../../helpers/kiosk/preProcessSharedBulkBuyingData';
 import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+import {
+	handleSwapCleanup,
+	handleSwapSetup,
+	type SwapAndPayOptions,
+} from '../../helpers/swap/swap';
 import {
 	addBluemoveBuyTxHandler,
 	addClutchyBuyTxHandler,
@@ -49,6 +53,7 @@ type BuyTxBase = {
 	remainingAccountBalance?: number;
 	royalty?: number;
 	sharedBulkBuyingDataByNftType?: SharedBulkBuyingDataByNftType;
+	amountToSplitFromSuiBalance?: bigint;
 };
 
 type NormalBuyTx = {
@@ -77,6 +82,7 @@ export type BuyListings = {
 	tx?: Transaction | string;
 	kioskTx?: KioskTransaction;
 	coinToSplit?: any;
+	swapAndPayOptions?: SwapAndPayOptions;
 	beforeResolveKioskTransferRequest?: (transferRequest: any) => void | Promise<void>;
 };
 
@@ -88,6 +94,7 @@ export const buyListings = async (
 		kioskTx,
 		coinToSplit,
 		beforeResolveKioskTransferRequest,
+		swapAndPayOptions,
 	}: BuyListings,
 	context: RequestContext,
 	marketFeeDecimalPercent?: number,
@@ -103,8 +110,15 @@ export const buyListings = async (
 	}
 
 	const listingsForTracking = [];
-	const tx = deserializeOrCreateTxBlock({ existingTx });
-	const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
+	let tx = deserializeOrCreateTxBlock({ existingTx });
+
+	const { transaction: updatedTx, swapResultCoin } = await handleSwapSetup(
+		context.suiClient,
+		walletAddress,
+		tx,
+		swapAndPayOptions,
+	);
+	tx = updatedTx;
 
 	const tocenTokenIds: string[] = [];
 	let tocenNftType = '';
@@ -162,6 +176,7 @@ export const buyListings = async (
 			beforeResolveKioskTransferRequest,
 			sharedKioskState,
 			sharedBulkBuyingDataByNftType,
+			amountToSplitFromSuiBalance: BigInt(swapAndPayOptions?.amountToSplitFromSuiBalance ?? 0n),
 		};
 
 		switch (listing?.market_name) {
@@ -211,9 +226,7 @@ export const buyListings = async (
 
 	sharedKioskState?.kioskTx?.finalize();
 
-	if (swapResultCoin) {
-		tx.transferObjects([swapResultCoin], walletAddress);
-	}
+	handleSwapCleanup(tx, swapResultCoin, walletAddress);
 
 	if (tocenTokenIds?.length > 0) {
 		addTocenBuyTxHandler({
@@ -233,5 +246,5 @@ export const buyListings = async (
 	// 	});
 	// }
 
-	return Transaction.from(tx);
+	return tx instanceof Transaction ? tx : Transaction.from(tx);
 };

package/src/methods/cancelNftTransfers/cancelNftTransfers.ts

@@ -114,5 +114,5 @@ export const cancelNftTransfers = async (
 	// 	});
 	// }
 
-	return Transaction.from(tx);
+	return tx instanceof Transaction ? tx : Transaction.from(tx);
 };

package/src/methods/claimNfts/claimNfts.ts

@@ -266,5 +266,5 @@ export const claimNfts = async (
 	// 	});
 	// }
 
-	return Transaction.from(tx);
+	return tx instanceof Transaction ? tx : Transaction.from(tx);
 };

package/src/methods/createMultiBid/createMultiBid.ts

@@ -1,8 +1,8 @@
 import { type Transaction } from '@mysten/sui/transactions';
 import { TRADEPORT_MULTI_BID_PACKAGE, TRADEPORT_MULTI_BID_STORE } from '../../constants';
 import { deserializeOrCreateTxBlock } from '../../helpers/deserializeOrCreateTxBlock';
+import { type RequestContext } from '../../SuiTradingClient';
 import { updateMultiBid } from '../updateMultiBid/updateMultiBid';
-
 export interface CreateMultiBid {
 	walletAddress: string;
 	name?: string;
@@ -10,12 +10,10 @@ export interface CreateMultiBid {
 	tx?: Transaction | string;
 }
 
-export async function createMultiBid({
-	walletAddress,
-	name,
-	amount,
-	tx: existingTx,
-}: CreateMultiBid): Promise<{ multiBidChainId: any; tx: Transaction }> {
+export async function createMultiBid(
+	{ walletAddress, name, amount, tx: existingTx }: CreateMultiBid,
+	context: RequestContext,
+): Promise<{ multiBidChainId: any; tx: Transaction }> {
 	const tx = deserializeOrCreateTxBlock({ existingTx });
 
 	const multiBidChainId = tx.moveCall({
@@ -30,6 +28,7 @@ export async function createMultiBid({
 			amount,
 			name,
 			tx,
+			suiClient: context.suiClient,
 		});
 	}
 

package/src/methods/listNfts/listNfts.ts

@@ -138,5 +138,5 @@ export const listNfts = async (
 	// 	});
 	// }
 
-	return Transaction.from(tx);
+	return tx instanceof Transaction ? tx : Transaction.from(tx);
 };

package/src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts

@@ -222,5 +222,5 @@ export async function migrateNftsFromUnsharedToSharedKiosks(
 
 	sharedKioskState?.kioskTx?.finalize();
 
-	return Transaction.from(tx);
+	return tx instanceof Transaction ? tx : Transaction.from(tx);
 }

package/src/methods/placeCollectionBids/placeCollectionBids.ts

@@ -6,12 +6,16 @@ import { ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK } from '../../constants';
 import { gqlChainRequest } from '../../graphql/gqlChainRequest';
 import { fetchCollectionsByIdWithOneNft } from '../../graphql/queries/fetchCollectionsById';
 import { deserializeOrCreateTxBlock } from '../../helpers/deserializeOrCreateTxBlock';
-import { extractSwapResultCoinFromTxBlock } from '../../helpers/extractSwapResultCoin';
 import { getNftType } from '../../helpers/getNftType';
 import { getSharedObjects } from '../../helpers/getSharedObjects';
 import { getOrCreateOBKiosk } from '../../helpers/originByte/getOrCreateOBKiosk';
 import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
 import { shareOriginByteKiosk } from '../../helpers/originByte/shareOriginByteKiosk';
+import {
+	handleSwapCleanup,
+	handleSwapSetup,
+	type SwapAndPayOptions,
+} from '../../helpers/swap/swap';
 import { normalizedNftType } from '../../utils/normalizeNftType';
 import { addTradePortPlaceNftBidTxHandler } from '../placeNftBids/addPlaceNftBidTxs';
 import { addOriginByteCollectionBidTx } from './addPlaceCollectionBidTxs';
@@ -33,6 +37,7 @@ export type PlaceCollectionBidTx = {
 	multiBidChainId?: any;
 	expireAt?: Date;
 	coinToSplit?: any;
+	amountToSplitFromSuiBalance?: bigint;
 };
 
 export type PlaceCollectionBid = {
@@ -44,6 +49,7 @@ export type PlaceCollectionBid = {
 	multiBidChainId?: any;
 	expireAt?: Date;
 	tx?: Transaction | string;
+	swapAndPayOptions?: SwapAndPayOptions;
 };
 
 export type PlaceCollectionBids = {
@@ -57,10 +63,18 @@ export type PlaceCollectionBids = {
 	multiBidId?: string;
 	multiBidChainId?: any;
 	tx?: Transaction | string;
+	swapAndPayOptions?: SwapAndPayOptions;
 };
 
 export const placeCollectionBids = async (
-	{ collections, walletAddress, multiBidId, multiBidChainId, tx: existingTx }: PlaceCollectionBids,
+	{
+		collections,
+		walletAddress,
+		multiBidId,
+		multiBidChainId,
+		tx: existingTx,
+		swapAndPayOptions,
+	}: PlaceCollectionBids,
 	context: RequestContext,
 ): Promise<Transaction> => {
 	const res = await gqlChainRequest({
@@ -74,8 +88,15 @@ export const placeCollectionBids = async (
 	}
 
 	const collectionsForTracking = [];
-	const tx = deserializeOrCreateTxBlock({ existingTx });
-	const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
+	let tx = deserializeOrCreateTxBlock({ existingTx });
+
+	const { transaction: updatedTx, swapResultCoin } = await handleSwapSetup(
+		context.suiClient,
+		walletAddress,
+		tx,
+		swapAndPayOptions,
+	);
+	tx = updatedTx;
 
 	for (const collection of res.collections) {
 		const nftType = getNftType({
@@ -99,6 +120,7 @@ export const placeCollectionBids = async (
 			multiBidChainId,
 			expireAt: collections?.find((c) => c.id === collection?.id)?.expireAt,
 			coinToSplit: swapResultCoin,
+			amountToSplitFromSuiBalance: BigInt(swapAndPayOptions?.amountToSplitFromSuiBalance ?? 0n),
 		};
 
 		const numOfBids = collections?.find((c) => c.id === collection?.id)?.numOfBids;
@@ -135,9 +157,7 @@ export const placeCollectionBids = async (
 		});
 	}
 
-	if (swapResultCoin) {
-		tx.transferObjects([swapResultCoin], walletAddress);
-	}
+	handleSwapCleanup(tx, swapResultCoin, walletAddress);
 
 	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && collectionsForTracking.length > 0) {
 	// 	trackMethodCall({
@@ -148,5 +168,5 @@ export const placeCollectionBids = async (
 	// 	});
 	// }
 
-	return Transaction.from(tx);
+	return tx instanceof Transaction ? tx : Transaction.from(tx);
 };