@tradeport/sui-trading-sdk 0.5.5 → 0.5.6

package/src/methods/listNfts/listNfts.ts

@@ -1,152 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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;
-};