@tradeport/sui-trading-sdk 0.0.0

package/src/methods/removeCollectionBid/removeCollectionBid.ts

@@ -0,0 +1,97 @@
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchCollectionBidById } from '../../graphql/queries/fetchCollectionBidById';
+import { fetchCollectionsByIdWithOneNft } from '../../graphql/queries/fetchCollectionsById';
+import { getNftTypeFromNft } from '../../helpers/getNftTypeFromNft';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import {
+	addBluemoveRemoveCollectionBidTxHandler,
+	addClutchyRemoveCollectionBidTxHandler,
+	addTradePortRemoveCollectionBidTxHandler,
+} from './addRemoveCollectionBidTxs';
+
+export type RemoveCollectionBidTx = {
+	txBlock: TransactionBlock;
+	sharedObjects: any;
+	bidNonce: string;
+	bidder: string;
+	nftType: string;
+	nftTokenId: string;
+	bidAmount: number;
+	sellerKiosk: string;
+	bidMarketName: string;
+};
+
+export type RemoveCollectionBid = {
+	bidId: string;
+};
+
+export const removeCollectionBid = async ({
+	bidId,
+}: RemoveCollectionBid): Promise<TransactionBlock> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchCollectionBidById,
+		variables: { bidId },
+	});
+
+	if (res?.bids?.length === 0) {
+		throw new Error('No bids found');
+	}
+
+	const txBlock = new TransactionBlock();
+
+	for (const bid of res.bids) {
+		let nftType;
+		if (
+			[
+				'fa58ae52-b18d-4179-a2d4-c2471ede5f14', // S-Card
+				'ca37bbb2-4398-46cb-b467-8a834d2d2612', // S-Card mint ticket
+				'c8e19183-3a9e-4312-939f-c63a1416e344', // Panzerdogs
+				'819eabe2-1565-4c3a-a9f6-1b5fca48e09a', // Panzerdog Tanks
+			]?.includes(bid?.collection_id)
+		) {
+			const collectionWithOneNftRes = await gqlChainRequest({
+				chain: 'sui',
+				query: fetchCollectionsByIdWithOneNft,
+				variables: { collectionIds: [bid?.collection_id] },
+			});
+			nftType = getNftTypeFromNft(collectionWithOneNftRes?.collections?.[0]?.nfts?.[0]);
+		} else if (bid?.collection_id === '07231735-96de-4710-8e11-52c61a482578') {
+			nftType =
+				'0x034c162f6b594cb5a1805264dd01ca5d80ce3eca6522e6ee37fd9ebfb9d3ddca::factory::PrimeMachin';
+		} else {
+			nftType = bid?.contract?.properties?.nft_type;
+		}
+
+		const sharedObjects = await getSharedObjects(nftType);
+
+		const txData: RemoveCollectionBidTx = {
+			txBlock,
+			sharedObjects,
+			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,
+		};
+
+		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');
+		}
+	}
+
+	return new TransactionBlock(txBlock);
+};

package/src/methods/removeNftBids/addRemoveNftBidTxs.ts

@@ -0,0 +1,84 @@
+import {
+	BLUEMOVE_OFFER_DATA_OBJECT,
+	TOCEN_MARKETPLACE_OBJECT,
+	TRADEPORT_BIDDING_STORE,
+	TRADEPORT_KIOSK_BIDDING_STORE,
+} from '../../constants';
+import { isTradePortKioskBid } from '../../helpers/kiosk/isTradePortKioskBid';
+import { isOriginByteBid } from '../../helpers/originByte/isOriginByteBid';
+import { getObjectType } from '../../helpers/rpc/getObjectType';
+import { type RemoveNftBidTx } from './removeNftBids';
+
+export function addTradeportRemoveNftBidTx({ txBlock, bidNonce, nftType }: RemoveNftBidTx) {
+	txBlock.moveCall({
+		target:
+			'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::cancel_bid',
+		arguments: [txBlock.object(TRADEPORT_BIDDING_STORE), txBlock.pure(bidNonce)],
+		typeArguments: [nftType],
+	});
+}
+
+export function addTradeportKioskRemoveNftBidTx({ txBlock, bidNonce, nftType }: RemoveNftBidTx) {
+	txBlock.moveCall({
+		target:
+			'0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_biddings::cancel_bid',
+		arguments: [txBlock.object(TRADEPORT_KIOSK_BIDDING_STORE), txBlock.pure(bidNonce)],
+		typeArguments: [nftType],
+	});
+}
+
+export function addOriginByteRemoveNftBidTx({ txBlock, bidNonce }: RemoveNftBidTx) {
+	txBlock.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::close_bid',
+		arguments: [txBlock.pure(bidNonce)],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+}
+
+export function addBluemoveRemoveNftBidTx({
+	txBlock,
+	bidNonce,
+	nftTokenId,
+	nftType,
+}: RemoveNftBidTx) {
+	txBlock.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_item::cancel_offer_nft',
+		arguments: [
+			txBlock.object(BLUEMOVE_OFFER_DATA_OBJECT),
+			txBlock.pure(nftTokenId),
+			txBlock.pure(bidNonce),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export function addTocenRemoveNftBidTx({ txBlock, nftTokenId, bidAmount }: RemoveNftBidTx) {
+	txBlock.moveCall({
+		target:
+			'0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::cancel_offer',
+		arguments: [
+			txBlock.pure(TOCEN_MARKETPLACE_OBJECT),
+			txBlock.pure(nftTokenId),
+			txBlock.pure(bidAmount),
+		],
+		typeArguments: [],
+	});
+}
+
+export async function addTradePortRemoveNftBidTxHandler(txData: RemoveNftBidTx) {
+	const bidType = await getObjectType(txData?.bidNonce);
+
+	if (isOriginByteBid(bidType)) {
+		addOriginByteRemoveNftBidTx(txData);
+		return;
+	}
+
+	if (isTradePortKioskBid(bidType)) {
+		addTradeportKioskRemoveNftBidTx(txData);
+		return;
+	}
+
+	addTradeportRemoveNftBidTx(txData);
+}

package/src/methods/removeNftBids/removeNftBids.ts

@@ -0,0 +1,80 @@
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchBidsById } from '../../graphql/queries/fetchBidsById';
+import { getNftTypeFromNft } from '../../helpers/getNftTypeFromNft';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import {
+	addBluemoveRemoveNftBidTx,
+	addOriginByteRemoveNftBidTx,
+	addTocenRemoveNftBidTx,
+	addTradePortRemoveNftBidTxHandler,
+} from './addRemoveNftBidTxs';
+
+export type RemoveNftBidTx = {
+	txBlock: TransactionBlock;
+	sharedObjects: any;
+	bidNonce: string;
+	nftType: string;
+	nftTokenId: string;
+	bidAmount: number;
+	sellerKiosk: string;
+	bidMarketName: string;
+};
+
+export type RemoveNftBid = {
+	bidId: string;
+};
+
+export type RemoveNftBids = {
+	bidIds: string[];
+};
+
+export const removeNftBids = async ({ bidIds }: RemoveNftBids): Promise<TransactionBlock> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchBidsById,
+		variables: { bidIds },
+	});
+
+	if (res?.bids?.length === 0) {
+		throw new Error('No bids found');
+	}
+
+	const txBlock = new TransactionBlock();
+
+	for (const bid of res.bids) {
+		const sharedObjects = await getSharedObjects(
+			bid?.nft?.properties?.nft_type || bid?.nft?.contract?.properties?.nft_type,
+		);
+
+		const txData: RemoveNftBidTx = {
+			txBlock,
+			sharedObjects,
+			bidNonce: bid?.nonce,
+			nftType: getNftTypeFromNft(bid?.nft),
+			nftTokenId: bid?.nft?.token_id,
+			bidAmount: bid?.price,
+			sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
+			bidMarketName: bid?.market_contract?.name,
+		};
+
+		switch (txData.bidMarketName) {
+			case 'tradeport':
+				await addTradePortRemoveNftBidTxHandler(txData);
+				break;
+			case 'clutchy':
+				addOriginByteRemoveNftBidTx(txData);
+				break;
+			case 'bluemove':
+				addBluemoveRemoveNftBidTx(txData);
+				break;
+			case 'tocen':
+				addTocenRemoveNftBidTx(txData);
+				break;
+			default:
+				throw new Error('Marketplace not supported');
+		}
+	}
+
+	return new TransactionBlock(txBlock);
+};

package/src/methods/transferNfts/addTransferNftTx.ts

@@ -0,0 +1,78 @@
+import {
+	TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK,
+	TRADEPORT_KIOSK_TRANSFERS_STORE,
+} from '../../constants';
+import { resolveTransferPolicies } from '../../helpers/kiosk/resolveTransferPolicies';
+import { getOBKiosk } from '../../helpers/originByte/getOBKiosk';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { type TransferNftTx } from './transferNfts';
+
+export async function addOriginByteTransferNftTx({
+	txBlock,
+	nftTokenId,
+	nftType,
+	recipientAddress,
+	senderKiosk,
+}: TransferNftTx) {
+	const recipientOBKiosk = await getOBKiosk(recipientAddress);
+
+	if (recipientOBKiosk) {
+		txBlock.moveCall({
+			target:
+				'0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer',
+			arguments: [
+				txBlock.object(senderKiosk),
+				txBlock.object(recipientOBKiosk),
+				txBlock.pure(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+	} else {
+		txBlock.moveCall({
+			target:
+				'0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer_and_create_target_kiosk',
+			arguments: [
+				txBlock.object(senderKiosk),
+				txBlock.pure(addLeadingZerosAfter0x(recipientAddress)),
+				txBlock.pure(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+	}
+}
+
+export async function addTradeportKioskTransferTx({
+	txBlock,
+	sharedObjects,
+	kioskTx,
+	nftTokenId,
+	nftType,
+	recipientAddress,
+}: TransferNftTx) {
+	const { transferPolicy } = sharedObjects;
+
+	const [transferRequest] = txBlock.moveCall({
+		target:
+			'0x78eae99d1a7edae714b5de107f4b44ccbdf5f9ca6919498d9b024ef378dc13f7::kiosk_transfers::transfer',
+		arguments: [
+			txBlock.object(TRADEPORT_KIOSK_TRANSFERS_STORE),
+			txBlock.object(TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK),
+			txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+			txBlock.pure(nftTokenId),
+			txBlock.pure(addLeadingZerosAfter0x(recipientAddress)),
+			txBlock.object(transferPolicy),
+		],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		txBlock,
+		kioskTx,
+		nftType,
+		price: '0',
+		transferRequest,
+		kioskToLockRuleProve: TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK,
+		shouldSkipKioskLocking: true,
+	});
+}

package/src/methods/transferNfts/transferNfts.ts

@@ -0,0 +1,107 @@
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchNftsById } from '../../graphql/queries/fetchNftsById';
+import { addOneDollarFee } from '../../helpers/addOneDollarFee';
+import { getNftTypeFromNft } from '../../helpers/getNftTypeFromNft';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { isOBKiosk } from '../../helpers/originByte/isOBKiosk';
+import { getAccountBalance } from '../../helpers/rpc/getAcountBalance';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { addOriginByteTransferNftTx, addTradeportKioskTransferTx } from './addTransferNftTx';
+
+export type TransferNftTx = {
+	txBlock: TransactionBlock;
+	nftType: string;
+	nftTokenId: string;
+	senderKiosk: string;
+	senderAddress: string;
+	recipientAddress: string;
+	sharedObjects?: any;
+	kioskTx?: any;
+};
+
+export type TransferNfts = {
+	nftIds: string[];
+	recipientAddress: string;
+	walletAddress: string;
+};
+
+export const transferNfts = async ({
+	nftIds,
+	recipientAddress,
+	walletAddress,
+}: TransferNfts): Promise<TransactionBlock> => {
+	if (addLeadingZerosAfter0x(recipientAddress) === addLeadingZerosAfter0x(walletAddress)) {
+		throw new Error('Cannot transfer to self');
+	}
+
+	const recipientAddressBalance = await getAccountBalance({ owner: recipientAddress });
+	// Recipient address needs to have a balance to be a valid address
+	if (!recipientAddressBalance || !recipientAddress?.includes('0x')) {
+		throw new Error('Invalid recipient address');
+	}
+
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchNftsById,
+		variables: { nftIds },
+	});
+
+	if (res?.nfts?.length === 0) {
+		throw new Error('No nfts found');
+	}
+
+	const txBlock = new TransactionBlock();
+
+	for (const nft of res.nfts) {
+		if (nft?.listed) {
+			throw new Error('Cannot transfer a listed NFT');
+		}
+
+		const sharedObjects = await getSharedObjects(getNftTypeFromNft(nft));
+
+		const txData: TransferNftTx = {
+			txBlock,
+			nftType: getNftTypeFromNft(nft),
+			nftTokenId: nft?.token_id,
+			senderKiosk: nft?.chain_state?.kiosk_id,
+			senderAddress: walletAddress,
+			recipientAddress,
+			sharedObjects,
+		};
+
+		// If NFT is not inside kiosk, transfer the NFT directly
+		if (!txData.senderKiosk) {
+			txBlock.transferObjects(
+				[txBlock.object(txData.nftTokenId)],
+				txBlock.pure(addLeadingZerosAfter0x(recipientAddress)),
+			);
+			continue;
+		}
+
+		const isSenderKioskOriginByte = await isOBKiosk(txData.senderAddress, txData.senderKiosk);
+
+		// If NFT is inside ob kiosk
+		if (isSenderKioskOriginByte) {
+			await addOriginByteTransferNftTx(txData);
+			continue;
+		}
+
+		// If NFT is inside native kiosk
+		await kioskTxWrapper({
+			txBlock: txData?.txBlock,
+			kioskOwner: txData?.senderAddress,
+			kiosk: txData?.senderKiosk,
+			async tx(kioskTx) {
+				await addTradeportKioskTransferTx({ ...txData, kioskTx });
+			},
+		});
+	}
+
+	if (res?.nfts?.length > 1) {
+		await addOneDollarFee(txBlock);
+	}
+
+	return new TransactionBlock(txBlock);
+};

package/src/methods/unlistListings/addUnlistListingTxs.ts

@@ -0,0 +1,258 @@
+import {
+	BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT,
+	BLUEMOVE_MARKET_CONFIG_OBJECT,
+	HYPERSPACE_MP_TRANSFER_POLICY_TYPE,
+	KEEPSAKE_MARKETPLACE_KIOSK,
+	KEEPSAKE_MARKETPLACE_OBJECT,
+	SOUFFL3_VERSION_OBJECT,
+	TOCEN_MARKETPLACE_OBJECT,
+	TRADEPORT_KIOSK_LISTING_STORE,
+	TRADEPORT_LISTING_STORE,
+} from '../../constants';
+import { isNonKioskListing } from '../../helpers/isNonKioskListing';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { isOriginByteTx } from '../../helpers/originByte/isOriginByteTx';
+import { splitCoins } from '../../helpers/splitCoins';
+import { type UnlistListingTx } from './unlistListings';
+
+export function addTradePortUnlistTx({ txBlock, listingNonce, nftType }: UnlistListingTx) {
+	txBlock.moveCall({
+		target: '0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::unlist',
+		arguments: [txBlock.object(TRADEPORT_LISTING_STORE), txBlock.pure(listingNonce)],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addTradePortKioskUnlistTx({
+	txBlock,
+	kioskTx,
+	nftTokenId,
+	nftType,
+}: UnlistListingTx) {
+	txBlock.moveCall({
+		target:
+			'0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_listings::unlist',
+		arguments: [
+			txBlock.object(TRADEPORT_KIOSK_LISTING_STORE),
+			txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+			txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export function addOriginByteUnlistTx({
+	txBlock,
+	sharedObjects,
+	listingNonce,
+	price,
+	nftTokenId,
+	nftType,
+}: UnlistListingTx) {
+	const { orderbook } = sharedObjects;
+
+	txBlock.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::cancel_ask',
+		arguments: [
+			txBlock.object(orderbook),
+			txBlock.object(listingNonce),
+			txBlock.pure(price),
+			txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+}
+
+export function addSouffl3UnlistTx({ txBlock, listingNonce, nftType }: UnlistListingTx) {
+	txBlock.moveCall({
+		target:
+			'0x30d90b5b67be77e6e06f02dae9f0f2fcdad16e38854316ae8a7b4f5b4971f5e0::Market::delist_generic',
+		arguments: [txBlock.object(SOUFFL3_VERSION_OBJECT), txBlock.pure(listingNonce)],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+}
+
+export function addBluemoveUnlistTx({ txBlock, nftTokenId, nftType }: UnlistListingTx) {
+	txBlock.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist_and_take',
+		arguments: [txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT), txBlock.pure(nftTokenId)],
+		typeArguments: [nftType, nftType],
+	});
+}
+
+export async function addBluemoveKioskUnlistTx({
+	txBlock,
+	kioskTx,
+	nftTokenId,
+	nftType,
+}: UnlistListingTx) {
+	txBlock.moveCall({
+		target:
+			'0x2949e130ca4dabfe6448173758468a3e45ea3f070e3264f112b51c023f3ecf9f::kiosk_trade::kiosk_delist',
+		arguments: [
+			txBlock.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
+			txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export function addKeepsakeUnlistTx({ txBlock, nftTokenId, nftType }: UnlistListingTx) {
+	txBlock.moveCall({
+		target:
+			'0x2be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::keepsake_marketplace::delist_and_take',
+		arguments: [
+			txBlock.object(KEEPSAKE_MARKETPLACE_OBJECT),
+			txBlock.object(KEEPSAKE_MARKETPLACE_KIOSK),
+			txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addHyperspaceKioskUnlistTx({
+	txBlock,
+	kioskTx,
+	nftTokenId,
+	nftType,
+}: UnlistListingTx) {
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(1)] });
+
+	txBlock.moveCall({
+		target:
+			'0x6ea97b03c441edd54ae89224bf9560e583ee66c37e6c246f5db35258e580ba94::hyperspace::delist',
+		arguments: [
+			txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+			txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType, HYPERSPACE_MP_TRANSFER_POLICY_TYPE],
+	});
+
+	txBlock.transferObjects([txBlock.object(coin)], txBlock.pure(nftTokenId));
+}
+
+export function addTocenUnlistTx({ txBlock, nftTokenId, nftType }: UnlistListingTx) {
+	txBlock.moveCall({
+		target:
+			'0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::delist_and_take',
+		arguments: [txBlock.pure(TOCEN_MARKETPLACE_OBJECT), txBlock.pure(nftTokenId)],
+		typeArguments: [nftType],
+	});
+}
+
+export function addSomisUnlistTx({
+	txBlock,
+	sharedObjects,
+	nftTokenId,
+	nftType,
+	price,
+}: UnlistListingTx) {
+	const { marketplace } = sharedObjects;
+
+	txBlock.moveCall({
+		target:
+			'0xf0b0beb956e26bde50dbd6ac393026c4525aee3b194a9478f09748f7211b5a02::marketplace::cancel_ask',
+		arguments: [txBlock.pure(marketplace), txBlock.pure(nftTokenId), txBlock.pure(price)],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+}
+
+export async function addTradePortUnlistTxHandler(txData: UnlistListingTx) {
+	if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+		addOriginByteUnlistTx(txData);
+		return;
+	}
+
+	if (txData?.listingNonce && (await isNonKioskListing(txData?.listingNonce))) {
+		addTradePortUnlistTx(txData);
+		return;
+	}
+
+	if (txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			txBlock: txData?.txBlock,
+			kioskOwner: txData?.seller,
+			kiosk: txData?.sellerKiosk,
+			async tx(kioskTx) {
+				await addTradePortKioskUnlistTx({
+					...txData,
+					kioskTx,
+				});
+			},
+		});
+	}
+
+	addTradePortUnlistTx(txData);
+}
+
+export async function addHyperspaceUnlistTxHandler(txData: UnlistListingTx) {
+	if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+		addOriginByteUnlistTx(txData);
+		return;
+	}
+
+	return kioskTxWrapper({
+		txBlock: txData?.txBlock,
+		kioskOwner: txData?.seller,
+		kiosk: txData?.sellerKiosk,
+		async tx(kioskTx) {
+			await addHyperspaceKioskUnlistTx({
+				...txData,
+				kioskTx,
+			});
+		},
+	});
+}
+
+export async function addBluemoveUnlistTxHandler(txData: UnlistListingTx) {
+	if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+		addOriginByteUnlistTx(txData);
+		return;
+	}
+
+	if (txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			txBlock: txData?.txBlock,
+			kioskOwner: txData?.seller,
+			kiosk: txData?.sellerKiosk,
+			async tx(kioskTx) {
+				await addBluemoveKioskUnlistTx({
+					...txData,
+					kioskTx,
+				});
+			},
+		});
+	}
+
+	addBluemoveUnlistTx(txData);
+}
+
+export async function addClutchyUnlistTxHandler(txData: UnlistListingTx) {
+	addOriginByteUnlistTx(txData);
+}
+
+export async function addSouffl3UnlistTxHandler(txData: UnlistListingTx) {
+	addSouffl3UnlistTx(txData);
+}
+
+export async function addSomisUnlistTxHandler(txData: UnlistListingTx) {
+	if (txData?.sharedObjects?.marketplace) {
+		addSomisUnlistTx(txData);
+		return;
+	}
+
+	addOriginByteUnlistTx(txData);
+}
+
+export async function addKeepsakeUnlistTxHandler(txData: UnlistListingTx) {
+	addKeepsakeUnlistTx(txData);
+}
+
+export function addTocenUnlistTxHandler(txData: UnlistListingTx) {
+	addTocenUnlistTx(txData);
+}