@tradeport/sui-trading-sdk 0.4.39 → 0.4.41

package/src/methods/listNfts/addListTxs.ts

@@ -1,14 +1,13 @@
 import {
 	ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK,
 	TRADEPORT_BENEFICIARY_ADDRESS,
-	TRADEPORT_KIOSK_LISTING_STORE,
-	TRADEPORT_LISTING_STORE,
+	TRADEPORT_LISTINGS_PACKAGE,
+	TRADEPORT_LISTINGS_STORE,
 } from '../../constants';
 import { getMarketFeePrice } from '../../helpers/getMarketFeePrice';
 import { getSharedObjects } from '../../helpers/getSharedObjects';
 import { hasNativeKioskTransferPolicyRules } from '../../helpers/hasTransferPolicyRules';
 import { assertNftInSharedKiosk } from '../../helpers/kiosk/assertNftInSharedKiosk';
-import { getNativeKioskTransferPolicies } from '../../helpers/kiosk/getNativeKioskTransferPolicies';
 import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
 import { takeAndBorrowNftFromKiosk } from '../../helpers/kiosk/takeAndBorrowNftFromKiosk';
 import { depositItemIntoOBKiosk } from '../../helpers/originByte/depositNftIntoOBKiosk';
@@ -16,6 +15,7 @@ import { getOrCreateOBKiosk } from '../../helpers/originByte/getOrCreateOBKiosk'
 import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
 import { shareOriginByteKiosk } from '../../helpers/originByte/shareOriginByteKiosk';
 import { normalizedNftType } from '../../utils/normalizeNftType';
+import { validateMinFloorPrice } from '../../helpers/validateMinFloorPrice';
 import { type ListNftTx } from './listNfts';
 
 export async function addOriginByteListTx({
@@ -79,66 +79,44 @@ export function addTradePortListTx({
 	nftTokenId,
 	borrowedItem,
 	nftType,
-	collectionId,
 	listPrice,
 }: ListNftTx) {
-	const marketFeePrice = getMarketFeePrice({ price: listPrice, collectionId });
-
 	tx.moveCall({
-		target: '0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::list',
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::create_listing_without_transfer_policy`,
 		arguments: [
-			tx.object(TRADEPORT_LISTING_STORE),
+			tx.object(TRADEPORT_LISTINGS_STORE),
 			borrowedItem ? tx.object(borrowedItem) : tx.object(nftTokenId),
 			tx.pure.u64(listPrice),
-			tx.pure.u64(marketFeePrice),
-			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
 		],
 		typeArguments: [nftType],
 	});
 }
 
-export async function addTradePortKioskListTx({
+export async function addKioskTradePortListTx({
 	tx,
 	kioskTx,
 	transferPolicies,
 	nftTokenId,
 	nftType,
-	collectionId,
 	listPrice,
 }: ListNftTx) {
-	const transferPolicy = getNativeKioskTransferPolicies(transferPolicies)?.at(0);
-	const minFloorPrice = transferPolicy?.rules?.filter(
-		(rule: any) => rule?.type === 'floor_price_rule',
-	)?.[0]?.floor_price;
-
-	if (minFloorPrice) {
-		if (listPrice < minFloorPrice) {
-			const formattedMinFloorPrice = Number(minFloorPrice) / 1000000000;
-			throw new Error(
-				`NFT Transfer Policy has a miminum floor price rule. Item cannot be listed for less than ${formattedMinFloorPrice} SUI`,
-			);
-		}
-	}
-
-	const marketFeePrice = getMarketFeePrice({ price: listPrice, collectionId });
+	validateMinFloorPrice({ transferPolicies, listPrice });
 
 	tx.moveCall({
-		target:
-			'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_listings::list',
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::create_listing_with_transfer_policy`,
 		arguments: [
-			tx.object(TRADEPORT_KIOSK_LISTING_STORE),
+			tx.object(TRADEPORT_LISTINGS_STORE),
 			tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
 			tx.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
-			tx.pure.address(nftTokenId),
-			tx.pure.u64(listPrice + marketFeePrice),
-			tx.pure.u64(marketFeePrice),
-			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
+			tx.pure.id(nftTokenId),
+			tx.pure.u64(listPrice),
 		],
 		typeArguments: [nftType],
 	});
 }
 
 export async function addTradePortListTxHandler(txData: ListNftTx) {
+	// If NFT is an Origin Byte collection, create an Origin Byte listing
 	if (
 		isOriginByteCollection(txData?.transferPolicies) &&
 		!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
@@ -181,6 +159,7 @@ export async function addTradePortListTxHandler(txData: ListNftTx) {
 		});
 	}
 
+	// If NFT is in a kiosk, create a kiosk listing
 	if (txData?.sellerKiosk) {
 		return kioskTxWrapper({
 			tx: txData?.tx,
@@ -191,7 +170,7 @@ export async function addTradePortListTxHandler(txData: ListNftTx) {
 			sharedKioskState: txData?.sharedKioskState,
 			shouldUseSharedKioskTx: false,
 			async runCommands(kioskTx) {
-				await addTradePortKioskListTx({
+				await addKioskTradePortListTx({
 					...txData,
 					kioskTx,
 				});
@@ -199,7 +178,7 @@ export async function addTradePortListTxHandler(txData: ListNftTx) {
 		});
 	}
 
-	// If NFT not in a kiosk, but nft type has a transfer policy rule, create kiosk and place NFT in kiosk first
+	// If NFT is not in a kiosk, but nft type has a transfer policy rule, create kiosk and place NFT in kiosk first
 	if (!txData?.sellerKiosk && hasNativeKioskTransferPolicyRules(txData?.transferPolicies)) {
 		return kioskTxWrapper({
 			tx: txData?.tx,
@@ -213,7 +192,7 @@ export async function addTradePortListTxHandler(txData: ListNftTx) {
 					item: txData?.nftTokenId,
 					itemType: txData?.nftType,
 				});
-				await addTradePortKioskListTx({
+				await addKioskTradePortListTx({
 					...txData,
 					kioskTx,
 				});
@@ -221,5 +200,6 @@ export async function addTradePortListTxHandler(txData: ListNftTx) {
 		});
 	}
 
+	// Fallback to non-kiosk listing
 	addTradePortListTx(txData);
 }

package/src/methods/listNfts/addRelistTxs.ts

@@ -3,10 +3,9 @@ import { type Transaction, type TransactionObjectArgument } from '@mysten/sui/tr
 import {
 	BLUEMOVE_MARKET_CONFIG_OBJECT,
 	TOCEN_MARKETPLACE_OBJECT,
-	TRADEPORT_BENEFICIARY_ADDRESS,
-	TRADEPORT_LISTING_STORE,
+	TRADEPORT_LISTINGS_PACKAGE,
+	TRADEPORT_LISTINGS_STORE,
 } from '../../constants';
-import { getMarketFeePrice } from '../../helpers/getMarketFeePrice';
 import { addTradePortListTx } from './addListTxs';
 import { type SuiClient } from '@mysten/sui/client';
 
@@ -26,30 +25,40 @@ export type RelistNftTx = {
 	sellerKiosk: string;
 };
 
-export function addTradePortRelistTx({
+export function addTradePortRelistTx({ tx, nftTokenId, nftType, listPrice }: RelistNftTx) {
+	tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::relist_listing_without_transfer_policy`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.pure.id(nftTokenId),
+			tx.pure.u64(listPrice),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addKioskTradePortRelistTx({
 	tx,
+	kioskTx,
+	nftTokenId,
 	nftType,
-	collectionId,
-	listingNonce,
 	listPrice,
 }: RelistNftTx) {
-	const marketFeePrice = getMarketFeePrice({ price: listPrice, collectionId });
-
 	tx.moveCall({
-		target: '0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::relist',
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::relist_listing_with_transfer_policy`,
 		arguments: [
-			tx.object(TRADEPORT_LISTING_STORE),
-			tx.pure.address(listingNonce),
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+			tx.pure.id(nftTokenId),
 			tx.pure.u64(listPrice),
-			tx.pure.u64(marketFeePrice),
-			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
 		],
 		typeArguments: [nftType],
 	});
 }
 
 export function addBlueMoveRelistTx(txData: RelistNftTx) {
-	const { tx, nftTokenId, nftType, listPrice, suiClient } = txData;
+	const { tx, nftTokenId, nftType, listPrice } = txData;
 
 	const borrowedItem = tx.moveCall({
 		target:
@@ -58,11 +67,11 @@ export function addBlueMoveRelistTx(txData: RelistNftTx) {
 		typeArguments: [nftType, nftType],
 	}) as TransactionObjectArgument;
 
-	addTradePortListTx({ ...txData, listPrice, borrowedItem, suiClient });
+	addTradePortListTx({ ...txData, listPrice, borrowedItem });
 }
 
 export function addTocenRelistTx(txData: RelistNftTx) {
-	const { tx, nftTokenId, nftType, listPrice, suiClient } = txData;
+	const { tx, nftTokenId, nftType, listPrice } = txData;
 
 	const borrowedItem = tx.moveCall({
 		target:
@@ -71,5 +80,5 @@ export function addTocenRelistTx(txData: RelistNftTx) {
 		typeArguments: [nftType],
 	}) as any;
 
-	addTradePortListTx({ ...txData, listPrice, borrowedItem, suiClient });
+	addTradePortListTx({ ...txData, listPrice, borrowedItem });
 }

package/src/methods/listNfts/listNfts.ts

@@ -1,7 +1,6 @@
 import { type KioskClient } from '@mysten/kiosk';
 import { type SuiClient } from '@mysten/sui/client';
 import { Transaction, type TransactionObjectInput } from '@mysten/sui/transactions';
-import { normalizeSuiAddress } from '@mysten/sui/utils';
 import { type RequestContext } from '../../SuiTradingClient';
 import {
 	DELOREAN_TOKEN_IDS_TO_DISABLE,
@@ -13,6 +12,10 @@ import { getNftType } from '../../helpers/getNftType';
 import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
 import { relistNft } from '../relistNft/relistNft';
 import { addTradePortListTxHandler } from './addListTxs';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { addSponsorListingTx } from '../sponsorNftListing/addSponsorNftListingTx';
+import { type SponsorNftListingOptions } from '../sponsorNftListing/sponsorNftListing';
+import { isExpiredListing } from '../../helpers/isExpiredListing';
 
 export type ListNftTx = {
 	tx: Transaction;
@@ -31,16 +34,11 @@ export type ListNftTx = {
 	sharedKioskState?: SharedKioskState;
 };
 
-export type ListNft = {
-	nftId: string;
-	listPriceInMist: number;
-	walletAddress: string;
-};
-
 export type ListNfts = {
 	nfts: Array<{
 		id: string;
 		listPriceInMist: number;
+		sponsorOptions?: SponsorNftListingOptions;
 	}>;
 	walletAddress: string;
 };
@@ -67,6 +65,8 @@ export const listNfts = async (
 	};
 
 	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);
 		}
@@ -79,14 +79,14 @@ export const listNfts = async (
 
 		const transferPolicies = nft?.collection?.chain_state?.transfer_policies;
 
-		// The NFT owner can also relist expired bids
+		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 }) =>
-					listing.nonce &&
-					listing.seller &&
-					normalizeSuiAddress(listing.seller) === normalizeSuiAddress(walletAddress),
+			nft.listings.some((listing: { nonce?: string; seller?: string }) =>
+				isExpiredListing(listing, walletAddress),
 			)
 		) {
 			await relistNft({
@@ -96,7 +96,7 @@ export const listNfts = async (
 				sharedKioskState,
 				transferPolicies,
 				nft,
-				listPrice: nfts?.find((n) => n.id === nft?.id)?.listPriceInMist,
+				listPrice: inputNft?.listPriceInMist,
 				walletAddress,
 			});
 		} else {
@@ -110,18 +110,29 @@ export const listNfts = async (
 				collectionId: nft?.collection_id,
 				nftTokenId: nft?.token_id,
 				nftType,
-				listPrice: nfts?.find((n) => n.id === nft?.id)?.listPriceInMist,
+				listPrice: inputNft?.listPriceInMist,
 				sellerKiosk: nft?.chain_state?.kiosk_id,
 			};
 
 			await addTradePortListTxHandler(listTxData);
 		}
 
+		if (inputNft?.sponsorOptions?.shouldSponsor) {
+			await addSponsorListingTx({
+				tx,
+				suiClient: context.suiClient,
+				nftTokenId: nft?.token_id,
+				nftType,
+				walletAddress,
+				sponsorOptions: inputNft?.sponsorOptions,
+			});
+		}
+
 		nftsForTracking.push({
 			walletAddress,
 			nftType,
 			collectionId: nft?.collection_id,
-			listPrice: nfts?.find((n) => n.id === nft?.id)?.listPriceInMist,
+			listPrice: inputNft?.listPriceInMist,
 			isRelist: nft?.listed,
 			marketRelistedFrom: nft?.listings?.[0]?.market_name,
 		});

package/src/methods/placeNftBids/addPlaceNftBidTxs.ts

@@ -105,7 +105,7 @@ export async function addTradePortPlaceNftBidTxHandler(txData: PlaceNftBidTx) {
 	}
 
 	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [
-		 multiBidChainId ? 0n : price + fee + royalty,
+		multiBidChainId ? 0n : price + fee + royalty,
 	]);
 	tx.moveCall({
 		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::create_bid_with${transferPolicy ? '' : 'out'}_transfer_policy`,

package/src/methods/relistNft/relistNft.ts

@@ -3,21 +3,20 @@ import { type SuiClient } from '@mysten/sui/client';
 import { type Transaction } from '@mysten/sui/transactions';
 import { ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK } from '../../constants';
 import { getNftType } from '../../helpers/getNftType';
-import { isNonKioskListing } from '../../helpers/isNonKioskListing';
 import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
 import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
 import { normalizedNftType } from '../../utils/normalizeNftType';
-import { addTradePortKioskListTx, addTradePortListTxHandler } from '../listNfts/addListTxs';
+import { addTradePortListTxHandler } from '../listNfts/addListTxs';
 import {
 	addBlueMoveRelistTx,
 	addTocenRelistTx,
 	addTradePortRelistTx,
+	addKioskTradePortRelistTx,
 } from '../listNfts/addRelistTxs';
 import {
 	addBluemoveUnlistTxHandler,
 	addClutchyUnlistTxHandler,
 	addHyperspaceUnlistTxHandler,
-	addTradePortKioskUnlistTx,
 	addTradePortUnlistTxHandler,
 } from '../unlistListings/addUnlistListingTxs';
 import { type UnlistListingTx } from '../unlistListings/unlistListings';
@@ -73,30 +72,24 @@ export async function relistNft({
 	switch (firstListedOrExpiredListing.market_name) {
 		case 'tradeport':
 			if (
-				(!isOriginByteCollection(txData?.transferPolicies) ||
-					ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) &&
 				txData?.listingNonce &&
-				(await isNonKioskListing({
-					suiClient: txData?.suiClient,
-					listingNonce: txData?.listingNonce,
-				}))
+				isOriginByteCollection(txData?.transferPolicies) &&
+				!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
 			) {
-				addTradePortRelistTx({ ...txData, listPrice });
-			} else {
-				if (
-					txData?.listingNonce &&
-					isOriginByteCollection(txData?.transferPolicies) &&
-					!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
-				) {
-					await addTradePortUnlistTxHandler(txData);
-					await addTradePortListTxHandler({
-						...txData,
-						listPrice,
-					});
+				await addTradePortUnlistTxHandler(txData);
+				await addTradePortListTxHandler({
+					...txData,
+					listPrice,
+				});
+				return;
+			}
 
-					return;
-				}
+			if (txData?.listingNonce?.startsWith('0::')) {
+				addTradePortRelistTx({ ...txData, listPrice });
+				return;
+			}
 
+			if (txData?.listingNonce?.startsWith('1::')) {
 				return kioskTxWrapper({
 					tx: txData?.tx,
 					kioskClient: txData?.kioskClient,
@@ -106,11 +99,7 @@ export async function relistNft({
 					sharedKioskState: txData?.sharedKioskState,
 					shouldUseSharedKioskTx: false,
 					async runCommands(kioskTx) {
-						await addTradePortKioskUnlistTx({
-							...txData,
-							kioskTx,
-						});
-						await addTradePortKioskListTx({
+						await addKioskTradePortRelistTx({
 							...txData,
 							kioskTx,
 							listPrice,
@@ -119,6 +108,8 @@ export async function relistNft({
 				});
 			}
 
+			await addTradePortUnlistTxHandler({ ...txData, isPartOfRelist: true });
+			await addTradePortListTxHandler({ ...txData, listPrice });
 			break;
 		case 'hyperspace':
 			await addHyperspaceUnlistTxHandler(txData);

package/src/methods/sponsorNftListing/addSponsorNftListingTx.ts

@@ -0,0 +1,71 @@
+import type { Transaction } from '@mysten/sui/transactions';
+import {
+	calculateSwapInputAmountWithSlippage,
+	createSwapTransaction,
+	transferBackExtraSwappedCoin,
+} from '../../helpers/swap';
+import { TRADEPORT_SPONSOR_USDC_FEE_AMOUNT_PER_PERIOD, USDC_COIN_TYPE } from '../../constants';
+import type { SuiClient } from '@mysten/sui/client';
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui.js/utils';
+import { TRADEPORT_LISTINGS_PACKAGE, TRADEPORT_LISTINGS_STORE } from '../../constants';
+import { type SponsorNftListingOptions } from './sponsorNftListing';
+import BigNumber from '../../bigNumberConfig';
+
+export const addSponsorListingTx = async ({
+	tx,
+	nftTokenId,
+	nftType,
+	suiClient,
+	walletAddress,
+	sponsorOptions,
+}: {
+	tx: Transaction;
+	nftTokenId: string;
+	nftType: string;
+	suiClient: SuiClient;
+	walletAddress: string;
+	sponsorOptions: SponsorNftListingOptions;
+}) => {
+	const coinInAmount = await calculateSwapInputAmountWithSlippage({
+		coinInType: sponsorOptions?.coinInType,
+		coinOutType: USDC_COIN_TYPE,
+		coinOutAmount: new BigNumber(TRADEPORT_SPONSOR_USDC_FEE_AMOUNT_PER_PERIOD)
+			?.times(sponsorOptions?.numOfPeriods)
+			.toString(),
+		slippage: sponsorOptions?.slippage,
+	});
+
+	const { coinOut } = await createSwapTransaction({
+		suiClient,
+		walletAddress,
+		options: {
+			transaction: tx,
+			coinInType: sponsorOptions?.coinInType,
+			coinInAmount,
+			coinOutType: USDC_COIN_TYPE,
+			slippage: sponsorOptions?.slippage,
+		},
+	});
+
+	const [sponsorFeeCoin] = tx.splitCoins(coinOut, [
+		tx.pure.u64(
+			new BigNumber(TRADEPORT_SPONSOR_USDC_FEE_AMOUNT_PER_PERIOD)
+				?.times(sponsorOptions?.numOfPeriods)
+				.toString(),
+		),
+	]);
+
+	tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::add_sponsored_listing`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(SUI_CLOCK_OBJECT_ID),
+			tx.pure.id(nftTokenId),
+			tx.pure.u64(sponsorOptions?.numOfPeriods),
+			tx.object(sponsorFeeCoin),
+		],
+		typeArguments: [nftType],
+	});
+
+	transferBackExtraSwappedCoin(tx, coinOut, walletAddress);
+};

package/src/methods/sponsorNftListing/sponsorNftListing.ts

@@ -0,0 +1,62 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchNftCollectionChainState } from '../../graphql/queries/fetchNftCollectionChainState';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import type { RequestContext } from '../../SuiTradingClient';
+import { addSponsorListingTx } from './addSponsorNftListingTx';
+import { getNftType } from '../../helpers/getNftType';
+
+export type SponsorNftListingOptions = {
+	shouldSponsor?: boolean;
+	numOfPeriods?: number;
+	slippage?: number;
+	coinInType?: string;
+};
+
+export type SponsorNftListing = {
+	nftTokenId: string;
+	walletAddress: string;
+	options: SponsorNftListingOptions;
+};
+
+export const sponsorNftListing = async (
+	{ nftTokenId, walletAddress, options }: SponsorNftListing,
+	context: RequestContext,
+): Promise<Transaction> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchNftCollectionChainState,
+		variables: { nftTokenId },
+	});
+
+	if (res?.nfts?.length === 0) {
+		throw new Error(`No nft found with token id ${nftTokenId}`);
+	}
+
+	const nft = res?.nfts?.[0];
+
+	const nftType = getNftType({
+		collectionId: nft?.collection?.id,
+		collectionChainState: nft?.collection?.chain_state,
+		nft,
+	});
+
+	const transferPolicies = nft?.collection?.chain_state?.transfer_policies;
+
+	if (isOriginByteCollection(transferPolicies)) {
+		throw new Error(`You cannot sponsor an Origin Byte NFT. Nft Token Id: ${nftTokenId}`);
+	}
+
+	const tx = new Transaction();
+
+	await addSponsorListingTx({
+		tx,
+		suiClient: context.suiClient,
+		nftTokenId,
+		nftType,
+		walletAddress,
+		sponsorOptions: options,
+	});
+
+	return Transaction.from(tx);
+};