@tradeport/sui-trading-sdk 0.5.3 → 0.5.4

package/src/methods/listNfts/listNfts.ts

@@ -0,0 +1,152 @@
+import { type KioskClient } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { Transaction, type TransactionObjectInput } 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 { fetchNftsWithListingsById } from '../../graphql/queries/fetchNftsById';
+import { getNftType } from '../../helpers/getNftType';
+import { isExpiredListing } from '../../helpers/isExpiredListing';
+import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { relistNft } from '../relistNft/relistNft';
+import { addSponsorListingTx } from '../sponsorNftListing/addSponsorNftListingTx';
+import { type SponsorNftListingOptions } from '../sponsorNftListing/sponsorNftListing';
+import { addTradePortListTxHandler } from './addListTxs';
+
+export type ListNftTx = {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	kioskClient: KioskClient;
+	kioskTx?: any;
+	sharedObjects?: any;
+	transferPolicies: any;
+	seller: string;
+	collectionId: string;
+	nftTokenId?: string;
+	borrowedItem?: TransactionObjectInput;
+	nftType: string;
+	listPrice: number;
+	sellerKiosk: string;
+	sharedKioskState?: SharedKioskState;
+};
+
+export type ListNfts = {
+	nfts: Array<{
+		id: string;
+		listPriceInMist: number;
+		sponsorOptions?: SponsorNftListingOptions;
+	}>;
+	walletAddress: string;
+	tx?: Transaction;
+};
+
+export const listNfts = async (
+	{ nfts, walletAddress, tx: existingTx }: ListNfts,
+	context: RequestContext,
+): Promise<Transaction> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchNftsWithListingsById,
+		variables: { nftIds: nfts.map((nft) => nft.id) },
+	});
+
+	if (res?.nfts?.length === 0) {
+		throw new Error('No nfts found');
+	}
+
+	const nftsForTracking = [];
+	const tx = existingTx ?? new Transaction();
+
+	const sharedKioskState: SharedKioskState = {
+		kioskTx: undefined,
+	};
+
+	for (const nft of res.nfts) {
+		const inputNft = nfts?.find((n) => n.id === nft?.id);
+
+		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;
+
+		if (inputNft?.sponsorOptions?.shouldSponsor && isOriginByteCollection(transferPolicies)) {
+			throw new Error(`You cannot sponsor an Origin Byte NFT. Nft Token Id: ${nft?.token_id}`);
+		}
+
+		if (
+			nft?.listed ||
+			nft.listings.some((listing: { nonce?: string; seller?: string }) =>
+				isExpiredListing(listing, walletAddress),
+			)
+		) {
+			await relistNft({
+				tx,
+				suiClient: context.suiClient,
+				kioskClient: context.kioskClient,
+				sharedKioskState,
+				transferPolicies,
+				nft,
+				listPrice: inputNft?.listPriceInMist,
+				walletAddress,
+			});
+		} else {
+			const listTxData: ListNftTx = {
+				tx,
+				suiClient: context.suiClient,
+				kioskClient: context.kioskClient,
+				sharedKioskState,
+				transferPolicies,
+				seller: walletAddress,
+				collectionId: nft?.collection_id,
+				nftTokenId: nft?.token_id,
+				nftType,
+				listPrice: inputNft?.listPriceInMist,
+				sellerKiosk: nft?.chain_state?.kiosk_id,
+			};
+
+			await addTradePortListTxHandler(listTxData);
+		}
+
+		if (inputNft?.sponsorOptions?.shouldSponsor) {
+			await addSponsorListingTx({
+				tx,
+				nftTokenId: nft?.token_id,
+				nftType,
+				sponsorOptions: inputNft?.sponsorOptions,
+			});
+		}
+
+		nftsForTracking.push({
+			walletAddress,
+			nftType,
+			collectionId: nft?.collection_id,
+			listPrice: inputNft?.listPriceInMist,
+			isRelist: nft?.listed,
+			marketRelistedFrom: nft?.listings?.[0]?.market_name,
+		});
+	}
+
+	sharedKioskState?.kioskTx?.finalize();
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && nftsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'LIST_NFTS',
+	// 		items: nftsForTracking,
+	// 	});
+	// }
+
+	return tx;
+};

package/src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts

@@ -0,0 +1,226 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { type RequestContext } from '../../SuiTradingClient';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchKiosksByOwner } from '../../graphql/queries/fetchKiosksByOwner';
+import {
+	fetchBulkNftsByKioskId,
+	fetchNftsByKioskId,
+} from '../../graphql/queries/fetchNftsByKioskId';
+import { getNftType } from '../../helpers/getNftType';
+import { getNativeKioskTransferPoliciesByNftType } from '../../helpers/kiosk/getNativeKioskTransferPoliciesByNftType';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { addClaimTransferredNftWithPurchaseCapTx } from '../claimNfts/addClaimNftsTxs';
+import { addTradeportKioskTransferTx } from '../transferNfts/addTransferNftTx';
+
+export type MigrateNftsFromUnsharedToSharedKiosks = {
+	walletAddress: string;
+	max?: number;
+};
+
+export async function migrateNftsFromUnsharedToSharedKiosks(
+	{ walletAddress, max = 50 }: MigrateNftsFromUnsharedToSharedKiosks,
+	context: RequestContext,
+): Promise<Transaction> {
+	const tx = new Transaction();
+
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchKiosksByOwner,
+		variables: { ownerAddress: addLeadingZerosAfter0x(walletAddress) },
+	});
+
+	const unsharedOBKiosks = res?.kiosks
+		?.filter((k: any) => !k.is_shared && k.is_origin_byte)
+		?.map((k: any) => k.id);
+
+	let currentMigrationCount = 0;
+
+	const sharedOBKiosk = res?.kiosks?.filter((k: any) => k.is_shared && k.is_origin_byte)?.[0]?.id;
+
+	for (const unsharedOBKiosk of unsharedOBKiosks) {
+		if (currentMigrationCount >= max) {
+			continue;
+		}
+
+		const res = await gqlChainRequest({
+			chain: 'sui',
+			query: fetchNftsByKioskId,
+			variables: { jsonFilter: { kiosk_id: unsharedOBKiosk } },
+		});
+
+		const nfts = res?.nfts;
+
+		if (nfts.length > 0) {
+			currentMigrationCount++;
+		}
+
+		for (const nft of nfts) {
+			if (nft?.chain_state?.claimable_trade_id) {
+				// origin byte trade hold, so they are stuck and cannot be migrated
+				continue;
+			}
+
+			const nftType = getNftType({
+				collectionId: nft?.collection?.id,
+				collectionChainState: nft?.collection?.chain_state,
+				nft,
+			});
+
+			const nftTokenId = nft?.token_id;
+
+			if (sharedOBKiosk) {
+				tx.moveCall({
+					target:
+						'0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer',
+					arguments: [
+						tx.object(unsharedOBKiosk),
+						tx.object(sharedOBKiosk),
+						tx.pure.address(nftTokenId),
+					],
+					typeArguments: [nftType],
+				});
+			} else {
+				tx.moveCall({
+					target:
+						'0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer_and_create_target_kiosk',
+					arguments: [
+						tx.object(unsharedOBKiosk),
+						tx.pure.address(addLeadingZerosAfter0x(walletAddress)),
+						tx.pure.address(nftTokenId),
+					],
+					typeArguments: [nftType],
+				});
+			}
+		}
+	}
+
+	const unsharedNativeKiosks = res?.kiosks
+		?.filter((k: any) => !k.is_shared && !k.is_origin_byte)
+		?.map((k: any) => k.id);
+
+	const allNfts = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchBulkNftsByKioskId,
+		variables: {
+			where: {
+				_or: unsharedNativeKiosks.map((nk: any) => ({
+					chain_state: { _contains: { kiosk_id: nk } },
+				})),
+			},
+		},
+	});
+
+	const formatted: any = {};
+	allNfts.nfts.forEach((e: any) => {
+		if (formatted[e.chain_state.kiosk_id]) {
+			formatted[e.chain_state.kiosk_id]?.push(e);
+		} else {
+			formatted[e.chain_state.kiosk_id] = [e];
+		}
+	});
+
+	const allNftTypes = allNfts.nfts.reduce((acc: any[], curr: any) => {
+		const type = getNftType({
+			collectionId: curr?.collection?.id,
+			collectionChainState: curr?.collection?.chain_state,
+			nft: curr,
+		});
+		if (!acc.includes(type)) acc.push(type);
+		return acc;
+	}, []);
+
+	const transferPolicies = await Promise.all(
+		allNftTypes.map(async (type: string) => getNativeKioskTransferPoliciesByNftType(type)),
+	);
+
+	const mappedTrasferPolicies: Record<string, any> = {};
+	transferPolicies.forEach((tp: any) => {
+		mappedTrasferPolicies[tp?.[0]?.type] = tp;
+	});
+
+	const sharedKioskState: SharedKioskState = {
+		kioskTx: undefined,
+	};
+
+	for (const unsharedNativeKiosk of unsharedNativeKiosks) {
+		if (currentMigrationCount >= max) {
+			continue;
+		}
+
+		const nfts = formatted[unsharedNativeKiosk] ?? [];
+		if (nfts?.length > 0) {
+			currentMigrationCount++;
+		}
+
+		for (const nft of nfts) {
+			let existingKioskTx;
+			if (nft?.claimable_reason === 'offer-transfer') {
+				// native kiosk kiosk_transfers transfer hold. Transfer needs to be cancelled first in order to be migrated
+				continue;
+			}
+
+			const nftType = getNftType({
+				collectionId: nft?.collection?.id,
+				collectionChainState: nft?.collection?.chain_state,
+				nft,
+			});
+			const nftTokenId = nft?.token_id;
+			await kioskTxWrapper({
+				tx,
+				kioskClient: context?.kioskClient,
+				kioskOwner: walletAddress,
+				kiosk: unsharedNativeKiosk,
+				shouldAllowNftUnsharedKiosk: true,
+				sharedKioskState,
+				shouldUseSharedKioskTx: false,
+				async runCommands(kioskTx) {
+					await addTradeportKioskTransferTx({
+						tx,
+						kioskTx,
+						kioskClient: context?.kioskClient,
+						suiClient: context?.suiClient,
+						senderKiosk: unsharedNativeKiosk,
+						senderAddress: walletAddress,
+						recipientAddress: walletAddress,
+						nftTokenId,
+						nftType,
+						transferPolicies: mappedTrasferPolicies[nftType],
+						transferPolicy: mappedTrasferPolicies[nftType]?.[0],
+					});
+				},
+			});
+			await kioskTxWrapper({
+				tx,
+				kioskClient: context.kioskClient,
+				kioskOwner: walletAddress,
+				kiosk: unsharedNativeKiosk,
+				kioskStrategy: 'exclude',
+				shouldConvertToPersonalKiosk: true,
+				sharedKioskState,
+				shouldUseSharedKioskTx: false,
+				async runCommands(kioskTx) {
+					await addClaimTransferredNftWithPurchaseCapTx({
+						tx,
+						kioskTx,
+						sharedObjects: [],
+						claimer: walletAddress,
+						kioskClient: context.kioskClient,
+						suiClient: context.suiClient,
+						nftTokenId,
+						nftType,
+						sellerKiosk: unsharedNativeKiosk,
+						seller: nft?.owner,
+						transferPolicies: mappedTrasferPolicies[nftType],
+						preloadedTransferPolicyId: mappedTrasferPolicies[nftType]?.[0]?.id,
+					});
+				},
+			});
+		}
+	}
+
+	sharedKioskState?.kioskTx?.finalize();
+
+	return Transaction.from(tx);
+}

package/src/methods/placeCollectionBids/addPlaceCollectionBidTxs.ts

@@ -0,0 +1,149 @@
+import {
+	TRADEPORT_BENEFICIARY_ADDRESS,
+	TRADEPORT_BIDDING_STORE,
+	TRADEPORT_KIOSK_BIDDING_STORE,
+} from '../../constants';
+import { destroyZeroCoin } from '../../helpers/destroyZeroCoin';
+import { getCollectionFloorPrice } from '../../helpers/getCollectionFloorPrice';
+import { getMarketFeePrice } from '../../helpers/getMarketFeePrice';
+import { getRoyaltyRuleModule } from '../../helpers/getRoyaltyRuleModule';
+import { getTradeportBiddingContractBidAmount } from '../../helpers/getTradeportBiddingContractBidAmount';
+import { hasRoyaltyRule } from '../../helpers/hasRoyaltyRule';
+import { getKioskPlaceBidCoin } from '../../helpers/kiosk/getKioskPlaceBidCoin';
+import { getNativeKioskTransferPolicies } from '../../helpers/kiosk/getNativeKioskTransferPolicies';
+import { getRulePackageId } from '../../helpers/kiosk/getRulePackageId';
+import { splitCoins } from '../../helpers/splitCoins';
+import { type PlaceCollectionBidTx } from './placeCollectionBids';
+
+export function addTradePortCollectionBidTx({
+	tx,
+	collectionId,
+	nftType,
+	bidAmount,
+}: PlaceCollectionBidTx) {
+	const amountToBid = getTradeportBiddingContractBidAmount({ bidAmount, collectionId });
+	const marketFeePrice = getMarketFeePrice({ price: bidAmount, collectionId });
+
+	const [coin] = splitCoins({ tx, amounts: [tx.pure.u64(amountToBid + marketFeePrice)] });
+
+	tx.moveCall({
+		target:
+			'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::collection_bid',
+		arguments: [
+			tx.object(TRADEPORT_BIDDING_STORE),
+			tx.pure.u64(amountToBid),
+			tx.object(coin),
+			tx.pure.u64(marketFeePrice),
+			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
+		],
+		typeArguments: [nftType],
+	});
+
+	destroyZeroCoin({ tx, coin });
+}
+
+export async function addTradePortKioskCollectionBidTx({
+	tx,
+	suiClient,
+	bidder,
+	collectionId,
+	nftType,
+	bidAmount,
+	royaltyRulePackageId,
+	royaltyRuleModule,
+	transferPolicies,
+}: PlaceCollectionBidTx) {
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const marketFeePrice = getMarketFeePrice({
+		price: bidAmount,
+		collectionId,
+	});
+
+	const coin = await getKioskPlaceBidCoin({
+		tx,
+		suiClient,
+		bidder,
+		nftType,
+		bidAmount,
+		marketFeePrice,
+		royaltyRulePackageId,
+		royaltyRuleModule,
+		transferPolicyId,
+	});
+
+	tx.moveCall({
+		target:
+			'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::collection_bid',
+		arguments: [
+			tx.object(TRADEPORT_KIOSK_BIDDING_STORE),
+			tx.pure.u64(bidAmount),
+			tx.object(coin),
+			tx.pure.u64(marketFeePrice),
+			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
+		],
+		typeArguments: [nftType],
+	});
+
+	destroyZeroCoin({ tx, coin });
+}
+
+export async function addOriginByteCollectionBidTx({
+	tx,
+	collectionId,
+	nftType,
+	bidAmount,
+	sharedObjects,
+	bidderKiosk,
+	coinToSplit,
+}: PlaceCollectionBidTx) {
+	const collectionFloorPrice = await getCollectionFloorPrice(collectionId);
+	if (
+		collectionFloorPrice &&
+		collectionFloorPrice > 0 &&
+		Number(bidAmount) > Number(collectionFloorPrice)
+	) {
+		throw new Error('Bid amount must be less than the collection floor price');
+	}
+
+	const { orderbook } = sharedObjects;
+
+	const marketFeePrice = getMarketFeePrice({ price: bidAmount, collectionId });
+
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [
+		tx.pure.u64(bidAmount + marketFeePrice),
+	]);
+
+	tx.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::create_bid_with_commission',
+		arguments: [
+			tx.object(orderbook),
+			tx.object(bidderKiosk),
+			tx.pure.u64(bidAmount),
+			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
+			tx.pure.u64(marketFeePrice),
+			tx.object(coin),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	destroyZeroCoin({ tx, coin });
+}
+
+export async function addTradePortPlaceCollectionBidTxHandler(txData: PlaceCollectionBidTx) {
+	if (hasRoyaltyRule(txData?.transferPolicies)) {
+		const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
+		const royaltyRulePackageId = await getRulePackageId({
+			transferPolicies: txData?.transferPolicies,
+			suiClient: txData?.suiClient,
+			nftType: txData.nftType,
+			ruleType: getRoyaltyRuleModule(txData?.collectionId),
+			kioskClient: txData?.kioskClient,
+		});
+		await addTradePortKioskCollectionBidTx({ ...txData, royaltyRulePackageId, royaltyRuleModule });
+		return;
+	}
+
+	addTradePortCollectionBidTx(txData);
+}

package/src/methods/placeCollectionBids/placeCollectionBids.ts

@@ -0,0 +1,153 @@
+import { type KioskClient } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { Transaction } from '@mysten/sui/transactions';
+import { type RequestContext } from '../../SuiTradingClient';
+import { ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK } from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchCollectionsByIdWithOneNft } from '../../graphql/queries/fetchCollectionsById';
+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 { normalizedNftType } from '../../utils/normalizeNftType';
+import { addTradePortPlaceNftBidTxHandler } from '../placeNftBids/addPlaceNftBidTxs';
+import { addOriginByteCollectionBidTx } from './addPlaceCollectionBidTxs';
+
+export type PlaceCollectionBidTx = {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	kioskClient: KioskClient;
+	sharedObjects?: any;
+	transferPolicies: any;
+	bidder: string;
+	collectionId: string;
+	nftType: string;
+	bidAmount: number;
+	bidderKiosk?: string;
+	royaltyRulePackageId?: string;
+	royaltyRuleModule?: string;
+	multiBidId?: string;
+	multiBidChainId?: any;
+	expireAt?: Date;
+	coinToSplit?: any;
+};
+
+export type PlaceCollectionBid = {
+	collectionId: string;
+	bidAmountInMist: number;
+	numOfBids: number;
+	walletAddress: string;
+	multiBidId?: string;
+	multiBidChainId?: any;
+	expireAt?: Date;
+	tx?: Transaction;
+};
+
+export type PlaceCollectionBids = {
+	collections: Array<{
+		id: string;
+		bidAmountInMist: number;
+		numOfBids: number;
+		expireAt?: Date;
+	}>;
+	walletAddress: string;
+	multiBidId?: string;
+	multiBidChainId?: any;
+	tx?: Transaction;
+	coinToSplit?: any;
+};
+
+export const placeCollectionBids = async (
+	{
+		collections,
+		walletAddress,
+		multiBidId,
+		multiBidChainId,
+		tx: existingTx,
+		coinToSplit,
+	}: PlaceCollectionBids,
+	context: RequestContext,
+): Promise<Transaction> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchCollectionsByIdWithOneNft,
+		variables: { collectionIds: collections.map((collection) => collection.id) },
+	});
+
+	if (res?.collections?.length === 0) {
+		throw new Error('No collection found');
+	}
+
+	const collectionsForTracking = [];
+	const tx = existingTx ?? new Transaction();
+
+	for (const collection of res.collections) {
+		const nftType = getNftType({
+			collectionId: collection?.id,
+			collectionChainState: collection?.chain_state,
+			nft: collection?.nfts?.[0],
+		});
+
+		const transferPolicies = collection?.chain_state?.transfer_policies;
+
+		const txData: PlaceCollectionBidTx = {
+			tx,
+			suiClient: context.suiClient,
+			kioskClient: context.kioskClient,
+			transferPolicies,
+			bidder: walletAddress,
+			collectionId: collection?.id,
+			nftType,
+			bidAmount: collections?.find((c) => c.id === collection?.id)?.bidAmountInMist,
+			multiBidId,
+			multiBidChainId,
+			expireAt: collections?.find((c) => c.id === collection?.id)?.expireAt,
+			coinToSplit,
+		};
+
+		const numOfBids = collections?.find((c) => c.id === collection?.id)?.numOfBids;
+
+		if (
+			isOriginByteCollection(txData?.transferPolicies) &&
+			!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
+		) {
+			const sharedObjects = await getSharedObjects(txData?.nftType);
+
+			const { kiosk: bidderKiosk, isNewKiosk: isNewBidderKiosk } = await getOrCreateOBKiosk({
+				tx,
+				address: txData.bidder,
+			});
+
+			for (let i = 0; i < numOfBids; i++) {
+				await addOriginByteCollectionBidTx({ ...txData, bidderKiosk, sharedObjects });
+			}
+
+			if (isNewBidderKiosk) {
+				shareOriginByteKiosk({ tx, kiosk: bidderKiosk });
+			}
+		} else {
+			for (let i = 0; i < numOfBids; i++) {
+				await addTradePortPlaceNftBidTxHandler({ ...txData, bidAmount: BigInt(txData.bidAmount) });
+			}
+		}
+
+		collectionsForTracking.push({
+			nftType,
+			collectionId: collection?.id,
+			bidAmount: collections?.find((c) => c.id === collection?.id)?.bidAmountInMist,
+			bidder: walletAddress,
+		});
+	}
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && collectionsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'PLACE_COLLECTION_BIDS',
+	// 		items: collectionsForTracking,
+	// 	});
+	// }
+
+	return tx;
+};