@tradeport/sui-trading-sdk 0.5.3 → 0.5.5

package/src/methods/placeNftBids/addPlaceNftBidTxs.ts

@@ -0,0 +1,154 @@
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { fromHex, normalizeSuiObjectId } from '@mysten/sui/utils';
+import {
+	DYNAMIC_COLLECTION_IDS,
+	ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK,
+	TRADEPORT_MULTI_BID_PACKAGE,
+	TRADEPORT_MULTI_BID_STORE,
+} from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import {
+	fetchMultibidChainIdAndExpiredSingleBidsById,
+	fetchMultibidChainIdById,
+} from '../../graphql/queries/fetchMultibidById';
+import { getNativeKioskTransferPolicies } from '../../helpers/kiosk/getNativeKioskTransferPolicies';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { normalizedNftType } from '../../utils/normalizeNftType';
+import { type PlaceNftBidTx } from './placeNftBids';
+import { addCancelSingleBidForMultibidChainId } from '../removeNftBids/addRemoveNftBidTxs';
+import { type Transaction } from '@mysten/sui/transactions';
+
+export async function addTradePortPlaceNftBidTxHandler(txData: PlaceNftBidTx) {
+	if (
+		isOriginByteCollection(txData?.transferPolicies) &&
+		!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
+	) {
+		throw new Error('OriginByte bidding not supported currently');
+	}
+
+	const {
+		tx,
+		nftType,
+		multiBidId,
+		multiBidChainId: existingMultiBidChainId,
+		nftTokenId,
+		collectionId,
+		bcsHex,
+		expireAt,
+		coinToSplit,
+	} = txData;
+	let bcs: Uint8Array | undefined;
+	if (nftTokenId && isDynamicCollection(collectionId)) {
+		if (!bcsHex) {
+			throw new Error(`No BCS found for token ${nftTokenId}`);
+		}
+
+		bcs = fromHex(bcsHex);
+	}
+
+	let multiBidChainId;
+	let expiredBids;
+	if (existingMultiBidChainId) {
+		multiBidChainId = existingMultiBidChainId;
+	} else {
+		const {
+			chain_id: chainId,
+			cancelled_at,
+			bids,
+		} = multiBidId
+			? ((
+					await gqlChainRequest({
+						chain: 'sui',
+						query: fetchMultibidChainIdAndExpiredSingleBidsById,
+						variables: { multiBidId, expiredBidLimit: 300 },
+					})
+				)?.multi_bids?.[0] ?? {})
+			: {};
+
+		if (chainId && cancelled_at) {
+			throw new Error(`MultiBid ${chainId} already cancelled`);
+		}
+
+		multiBidChainId = chainId;
+		expiredBids = bids;
+	}
+
+	const transferPolicies = getNativeKioskTransferPolicies(txData?.transferPolicies);
+	const transferPolicy = transferPolicies?.find(
+		(policy: { rules: any[] }) => policy?.rules?.length > 0,
+	);
+	const price = BigInt(txData?.bidAmount ?? 0n);
+	const fee = (BigInt(txData?.bidAmount ?? 0) * (await getBidFeeBps(txData?.suiClient))) / 10_000n;
+	let royalty = 0n;
+	const royaltyRule = (transferPolicy?.rules ?? []).find((r: { type: string }) =>
+		r.type.endsWith('royalty_rule'),
+	);
+
+	if (royaltyRule) {
+		const { amount_bp, min_amount } = royaltyRule;
+		royalty = BigInt((price * BigInt(amount_bp)) / 10_000n);
+		if (royalty < BigInt(min_amount ?? 0n)) {
+			royalty = BigInt(min_amount ?? 0n);
+		}
+	}
+
+	const txWithState = tx as Transaction & { hasCancelBidTransactions: Map<string, boolean> };
+	txWithState.hasCancelBidTransactions ??= new Map<string, boolean>();
+
+	if (multiBidChainId && !txWithState.hasCancelBidTransactions.get(multiBidChainId)) {
+		// Clean up expired bids in existing multibid
+		for (const { nonce } of expiredBids ?? []) {
+			addCancelSingleBidForMultibidChainId(tx, nonce, multiBidChainId);
+		}
+
+		txWithState.hasCancelBidTransactions.set(multiBidChainId, true);
+	}
+
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [
+		multiBidChainId ? 0n : price + fee + royalty,
+	]);
+	tx.moveCall({
+		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::create_bid_with${transferPolicy ? '' : 'out'}_transfer_policy`,
+		typeArguments: [nftType],
+		arguments: [
+			tx.object(TRADEPORT_MULTI_BID_STORE),
+			tx.pure.u64(nftTokenId ? 1 : 0),
+			multiBidChainId
+				? typeof multiBidChainId === 'string'
+					? tx.pure.option('id', normalizeSuiObjectId(multiBidChainId))
+					: tx.moveCall({
+							target: '0x1::option::some',
+							typeArguments: ['0x2::object::ID'],
+							arguments: [multiBidChainId],
+						})
+				: undefined,
+			tx.pure.option('id', nftTokenId ? normalizeSuiObjectId(nftTokenId) : undefined),
+			tx.pure.option('vector<u8>', bcs ? [...bcs] : undefined),
+			tx.pure.option('u64', expireAt?.getTime()),
+			tx.pure.u64(price),
+			...(transferPolicy ? [tx.object(transferPolicy.id)] : []),
+			tx.object(coin),
+		],
+	});
+}
+
+let bidFeeBps: bigint | undefined;
+
+export async function getBidFeeBps(suiClient: SuiGrpcClient) {
+	if (bidFeeBps !== undefined) {
+		return bidFeeBps;
+	}
+
+	const res = await suiClient.getObject({
+		objectId: TRADEPORT_MULTI_BID_STORE,
+		include: { json: true },
+	});
+
+	bidFeeBps = BigInt((res?.object?.json as unknown as { fee_bps: string })?.fee_bps ?? 0);
+
+	return bidFeeBps;
+}
+
+export function isDynamicCollection(collectionId: string): boolean {
+	return DYNAMIC_COLLECTION_IDS.includes(collectionId);
+}

package/src/methods/placeNftBids/placeNftBids.ts

@@ -0,0 +1,111 @@
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { Transaction } from '@mysten/sui/transactions';
+import { type RequestContext } from '../../SuiTradingClient';
+import {
+	DELOREAN_TOKEN_IDS_TO_DISABLE,
+	DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE,
+} from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchNftsById } from '../../graphql/queries/fetchNftsById';
+import { getNftType } from '../../helpers/getNftType';
+import { addTradePortPlaceNftBidTxHandler } from './addPlaceNftBidTxs';
+
+export type PlaceNftBidTx = {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	bidder: string;
+	collectionId: string;
+	nftTokenId?: string;
+	nftType: string;
+	bidAmount: bigint;
+	multiBidId?: string;
+	multiBidChainId?: any;
+	expireAt?: Date;
+	sharedObjects?: any;
+	transferPolicies: any;
+	bcsHex?: string;
+	coinToSplit?: any;
+};
+
+export type PlaceNftBids = {
+	bids: Array<{
+		nftId: string;
+		bidAmountInMist: number;
+		expireAt?: Date;
+	}>;
+	walletAddress: string;
+	multiBidId?: string;
+	multiBidChainId?: any;
+	tx?: Transaction;
+	coinToSplit?: any;
+};
+
+export const placeNftBids = async (
+	{ bids, walletAddress, multiBidId, multiBidChainId, tx: existingTx, coinToSplit }: PlaceNftBids,
+	context: RequestContext,
+): Promise<Transaction> => {
+	const tx = existingTx ?? new Transaction();
+
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchNftsById,
+		variables: { nftIds: bids.map((bid) => bid.nftId) },
+	});
+
+	if (res?.nfts?.length === 0) {
+		throw new Error('No nfts found');
+	}
+
+	const nftsForTracking = [];
+	for (const bid of bids) {
+		const nft = res.nfts?.find((nft: any) => nft.id === bid.nftId);
+
+		if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(nft?.token_id)) {
+			throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
+		}
+
+		const nftType = getNftType({
+			collectionId: nft?.collection_id,
+			collectionChainState: nft?.collection?.chain_state,
+			nft,
+		});
+
+		const transferPolicies = nft?.collection?.chain_state?.transfer_policies;
+
+		const txData: PlaceNftBidTx = {
+			tx,
+			suiClient: context.suiClient,
+			transferPolicies,
+			bidder: walletAddress,
+			collectionId: nft?.collection_id,
+			nftTokenId: nft?.token_id,
+			nftType,
+			bidAmount: BigInt(bid?.bidAmountInMist ?? 0n),
+			bcsHex: nft.chain_state?.bcs?.bcsHex,
+			multiBidId,
+			multiBidChainId,
+			expireAt: bid?.expireAt,
+			coinToSplit,
+		};
+
+		await addTradePortPlaceNftBidTxHandler(txData);
+
+		nftsForTracking.push({
+			nftType,
+			collectionId: nft?.collection_id,
+			bidAmount: bid?.bidAmountInMist,
+			bidder: walletAddress,
+		});
+	}
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && nftsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'PLACE_NFT_BIDS',
+	// 		items: nftsForTracking,
+	// 	});
+	// }
+
+	return tx;
+};

package/src/methods/relistNft/relistNft.ts

@@ -0,0 +1,153 @@
+import { type KioskClient } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { type Transaction } from '@mysten/sui/transactions';
+import { ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK } from '../../constants';
+import { getNftType } from '../../helpers/getNftType';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { normalizedNftType } from '../../utils/normalizeNftType';
+import { addTradePortListTxHandler } from '../listNfts/addListTxs';
+import {
+	addBlueMoveRelistTx,
+	addTocenRelistTx,
+	addTradePortRelistTx,
+	addKioskTradePortRelistTx,
+} from '../listNfts/addRelistTxs';
+import {
+	addBluemoveUnlistTxHandler,
+	addClutchyUnlistTxHandler,
+	addHyperspaceUnlistTxHandler,
+	addTradePortUnlistTxHandler,
+} from '../unlistListings/addUnlistListingTxs';
+import { type UnlistListingTx } from '../unlistListings/unlistListings';
+import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+
+interface Args {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	kioskClient: KioskClient;
+	sharedKioskState: SharedKioskState;
+	transferPolicies: any;
+	nft: any;
+	listPrice: number;
+	walletAddress: string;
+}
+
+export async function relistNft({
+	tx,
+	suiClient,
+	kioskClient,
+	sharedKioskState,
+	nft,
+	listPrice,
+	transferPolicies,
+	walletAddress,
+}: Args) {
+	const firstListedOrExpiredListing = (
+		nft?.listings as Array<{ listed: boolean; price?: number; nonce?: string; market_name: string }>
+	).find((l) => l.listed || l.nonce);
+	if (!firstListedOrExpiredListing) {
+		throw new Error('No listing found for NFT');
+	}
+
+	const txData: UnlistListingTx = {
+		tx,
+		suiClient,
+		kioskClient,
+		sharedKioskState,
+		transferPolicies,
+		nftTokenId: nft?.token_id,
+		nftType: getNftType({
+			collectionId: nft?.collection?.id,
+			collectionChainState: nft?.collection?.chain_state,
+			nft,
+		}),
+		listingNonce: firstListedOrExpiredListing.nonce,
+		price: firstListedOrExpiredListing.price,
+		sellerKiosk: nft?.chain_state?.kiosk_id,
+		collectionId: nft?.collection_id,
+		seller: walletAddress,
+	};
+
+	switch (firstListedOrExpiredListing.market_name) {
+		case 'tradeport':
+			if (
+				txData?.listingNonce &&
+				isOriginByteCollection(txData?.transferPolicies) &&
+				!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
+			) {
+				await addTradePortUnlistTxHandler(txData);
+				await addTradePortListTxHandler({
+					...txData,
+					listPrice,
+				});
+				return;
+			}
+
+			if (txData?.listingNonce?.startsWith('0::')) {
+				addTradePortRelistTx({ ...txData, listPrice });
+				return;
+			}
+
+			if (txData?.listingNonce?.startsWith('1::')) {
+				return kioskTxWrapper({
+					tx: txData?.tx,
+					kioskClient: txData?.kioskClient,
+					kioskOwner: txData?.seller,
+					kiosk: txData?.sellerKiosk,
+					shouldAssertNftInSharedKiosk: true,
+					sharedKioskState: txData?.sharedKioskState,
+					shouldUseSharedKioskTx: false,
+					async runCommands(kioskTx) {
+						await addKioskTradePortRelistTx({
+							...txData,
+							kioskTx,
+							listPrice,
+						});
+					},
+				});
+			}
+
+			await addTradePortUnlistTxHandler({ ...txData, isPartOfRelist: true });
+			await addTradePortListTxHandler({ ...txData, listPrice });
+			break;
+		case 'hyperspace':
+			await addHyperspaceUnlistTxHandler(txData);
+			await addTradePortListTxHandler({ ...txData, listPrice });
+			break;
+		case 'bluemove':
+			if (
+				!isOriginByteCollection(txData?.transferPolicies) ||
+				(ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType)) &&
+					!txData?.sellerKiosk)
+			) {
+				addBlueMoveRelistTx({ ...txData, listPrice });
+			} else {
+				await addBluemoveUnlistTxHandler(txData);
+				await addTradePortListTxHandler({ ...txData, listPrice });
+			}
+
+			break;
+		case 'clutchy':
+			await addClutchyUnlistTxHandler(txData);
+			await addTradePortListTxHandler({ ...txData, listPrice });
+			break;
+		case 'souffl3':
+			// Souffl3 contract does not support relists
+
+			break;
+		case 'somis':
+			// Somis contract does not support relists
+
+			break;
+		case 'keepsake':
+			// Keepsake contract does not support relists
+
+			break;
+		case 'tocen':
+			addTocenRelistTx({ ...txData, listPrice });
+			break;
+		default:
+			throw new Error('Marketplace not supported');
+	}
+}

package/src/methods/removeCollectionBids/addRemoveCollectionBidsTxs.ts

@@ -0,0 +1,132 @@
+import { normalizeSuiObjectId } from '@mysten/sui/utils';
+import {
+	BLUEMOVE_KIOSK_OFFER_COLLECTION_DATA_OBJECT,
+	BLUEMOVE_OFFER_COLLECTION_DATA_OBJECT,
+	TRADEPORT_BIDDING_STORE,
+} from '../../constants';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { isSingleBid } from '../../helpers/isSIngleBid';
+import { isBluemoveKioskBid } from '../../helpers/kiosk/isBluemoveKioskBid';
+import { isTradePortKioskBid } from '../../helpers/kiosk/isTradePortKioskBid';
+import { isOriginByteBid } from '../../helpers/originByte/isOriginByteBid';
+import { getObjectType } from '../../helpers/rpc/getObjectType';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import {
+	addSingleBidRemoveNftBidTx,
+	addTradeportKioskRemoveNftBidTx,
+} from '../removeNftBids/addRemoveNftBidTxs';
+import { type RemoveCollectionBidTx } from './removeCollectionBids';
+
+export function addTradeportRemoveCollectionBidTx({
+	tx,
+	nftType,
+	bidNonce,
+}: RemoveCollectionBidTx) {
+	tx.moveCall({
+		target:
+			'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::cancel_bid',
+		arguments: [tx.object(TRADEPORT_BIDDING_STORE), tx.pure.address(bidNonce)],
+		typeArguments: [nftType],
+	});
+}
+
+export function addTradePortKioskRemoveCollectionBidTx(txData: RemoveCollectionBidTx) {
+	addTradeportKioskRemoveNftBidTx(txData);
+}
+
+export function addOriginByteRemoveCollectionBidTx({
+	tx,
+	nftType,
+	bidAmount,
+	bidder,
+	sharedObjects,
+}: RemoveCollectionBidTx) {
+	const { orderbook } = sharedObjects;
+
+	const [coin] = tx.moveCall({
+		target: '0x2::coin::zero',
+		arguments: [],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+
+	tx.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::cancel_bid',
+		arguments: [tx.object(orderbook), tx.pure.u64(bidAmount), tx.object(coin)],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	tx.transferObjects([tx.object(coin)], tx.pure.address(addLeadingZerosAfter0x(bidder)));
+}
+
+export function addBluemoveRemoveCollectionBidTx({ tx, nftType, bidNonce }: RemoveCollectionBidTx) {
+	tx.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_collection::cancel_offer_collection',
+		arguments: [tx.object(BLUEMOVE_OFFER_COLLECTION_DATA_OBJECT), tx.pure.u64(bidNonce)],
+		typeArguments: [nftType],
+	});
+}
+
+export function addBluemoveKioskRemoveCollectionBidTx({
+	tx,
+	nftType,
+	bidNonce,
+}: RemoveCollectionBidTx) {
+	tx.moveCall({
+		target:
+			'0xcc97b74ed95c8e8a3ed88050a898727dee37896da579fc400d482b64db6149ff::kiosk_offer_collection_v2::cancel_offer_collection_v2',
+		arguments: [tx.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_DATA_OBJECT), tx.pure.u64(bidNonce)],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addTradePortRemoveCollectionBidTxHandler(txData: RemoveCollectionBidTx) {
+	const bidType = await getObjectType({
+		suiClient: txData?.suiClient,
+		objectId: normalizeSuiObjectId(txData?.bidNonce),
+	});
+
+	if (isSingleBid(bidType)) {
+		await addSingleBidRemoveNftBidTx(txData);
+		return;
+	}
+
+	if (isOriginByteBid(bidType)) {
+		const sharedObjects = await getSharedObjects(txData?.nftType);
+		addOriginByteRemoveCollectionBidTx({ ...txData, sharedObjects });
+		return;
+	}
+
+	if (isTradePortKioskBid(bidType)) {
+		addTradePortKioskRemoveCollectionBidTx(txData);
+		return;
+	}
+
+	addTradeportRemoveCollectionBidTx(txData);
+}
+
+export async function addBluemoveRemoveCollectionBidTxHandler(txData: RemoveCollectionBidTx) {
+	const bidType = await getObjectType({
+		suiClient: txData?.suiClient,
+		objectId: normalizeSuiObjectId(txData?.bidNonce),
+	});
+
+	if (isOriginByteBid(bidType)) {
+		const sharedObjects = await getSharedObjects(txData?.nftType);
+		addOriginByteRemoveCollectionBidTx({ ...txData, sharedObjects });
+		return;
+	}
+
+	if (isBluemoveKioskBid(txData?.bidNonce)) {
+		addBluemoveKioskRemoveCollectionBidTx(txData);
+		return;
+	}
+
+	addBluemoveRemoveCollectionBidTx(txData);
+}
+
+export async function addClutchyRemoveCollectionBidTxHandler(txData: RemoveCollectionBidTx) {
+	const sharedObjects = await getSharedObjects(txData?.nftType);
+	addOriginByteRemoveCollectionBidTx({ ...txData, sharedObjects });
+}

package/src/methods/removeCollectionBids/removeCollectionBids.ts

@@ -0,0 +1,117 @@
+import type { SuiGrpcClient } from '@mysten/sui/grpc';
+import { Transaction } from '@mysten/sui/transactions';
+import { type RequestContext } from '../../SuiTradingClient';
+import {
+	DELOREAN_TOKEN_IDS_TO_DISABLE,
+	DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE,
+} from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchCollectionBidsById } from '../../graphql/queries/fetchCollectionBidById';
+import { fetchCollectionsByIdWithOneNft } from '../../graphql/queries/fetchCollectionsById';
+import { getNftType } from '../../helpers/getNftType';
+import {
+	addBluemoveRemoveCollectionBidTxHandler,
+	addClutchyRemoveCollectionBidTxHandler,
+	addTradePortRemoveCollectionBidTxHandler,
+} from './addRemoveCollectionBidsTxs';
+
+export type RemoveCollectionBidTx = {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	sharedObjects?: any;
+	bidNonce: string;
+	bidder: string;
+	nftType: string;
+	nftTokenId: string;
+	bidAmount: number;
+	sellerKiosk: string;
+	bidMarketName: string;
+	multiBidId?: string;
+};
+
+export type RemoveCollectionBids = {
+	bidIds: string[];
+	tx?: Transaction | string;
+};
+
+export const removeCollectionBids = async (
+	{ bidIds, tx: existingTx }: RemoveCollectionBids,
+	context: RequestContext,
+): Promise<Transaction> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchCollectionBidsById,
+		variables: { bidIds },
+	});
+
+	if (res?.bids?.length === 0) {
+		throw new Error('No bids found');
+	}
+
+	const bidsForTracking = [];
+	const tx = existingTx ? Transaction.from(existingTx) : new Transaction();
+
+	for (const bid of res.bids) {
+		if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(bid?.nft?.token_id)) {
+			throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
+		}
+
+		const collectionWithOneNftRes = await gqlChainRequest({
+			chain: 'sui',
+			query: fetchCollectionsByIdWithOneNft,
+			variables: { collectionIds: [bid?.collection_id] },
+		});
+
+		const nftType = getNftType({
+			collectionId: collectionWithOneNftRes?.collections?.[0]?.id,
+			collectionChainState: collectionWithOneNftRes?.collections?.[0]?.chain_state,
+			nft: collectionWithOneNftRes?.collections?.[0]?.nfts?.[0],
+		});
+
+		const txData: RemoveCollectionBidTx = {
+			tx,
+			suiClient: context.suiClient,
+			bidNonce: bid?.nonce,
+			bidder: bid?.bidder,
+			nftType,
+			nftTokenId: bid?.nft?.token_id,
+			bidAmount: bid?.price,
+			sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
+			bidMarketName: bid?.market_contract?.name,
+			multiBidId: bid?.multi_bid_id,
+		};
+
+		switch (txData.bidMarketName) {
+			case 'tradeport':
+				await addTradePortRemoveCollectionBidTxHandler(txData);
+				break;
+			case 'bluemove':
+				await addBluemoveRemoveCollectionBidTxHandler(txData);
+				break;
+			case 'clutchy':
+				await addClutchyRemoveCollectionBidTxHandler(txData);
+				break;
+			default:
+				throw new Error('Marketplace not supported');
+		}
+
+		bidsForTracking.push({
+			nftType,
+			collectionId: bid?.collection_id,
+			bidAmount: bid?.price,
+			bidMarketName: bid?.market_contract?.name,
+			bidder: bid?.bidder,
+		});
+	}
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && bidsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'REMOVE_COLLECTION_BID',
+	// 		items: bidsForTracking,
+	// 	});
+	// }
+
+	return Transaction.from(tx);
+};