@tradeport/sui-trading-sdk 0.4.39 → 0.4.41

package/dist/index.mjs

@@ -113,8 +113,11 @@ var MYSTEN_TRANFER_POLICY_RULES_PACKAGE_ID = "0x434b5bd8f6a7b05fede0ff46c6e511d7
 var TRADEPORT_BENEFICIARY_ADDRESS = "0xbca3b5c01c8d1a93aed3a036feff45145518292dd3c1db1d67cc99a699a7b517";
 var TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT = 0.03;
 var TRADEPORT_THIRD_PARTY_FEE_DECIMAL_PERCENT = 5e-3;
+var TRADEPORT_LISTINGS_DEFAULT_COMMISSION_BPS = 300;
 var TRADEPORT_LISTING_STORE = "0x47cba0b6309a12ce39f9306e28b899ed4b3698bce4f4911fd0c58ff2329a2ff6";
 var TRADEPORT_BIDDING_STORE = "0x3d3b0c6e616fdc1a45b2b73d022bc085448e78bd729d28081c7a340abb33cba1";
+var TRADEPORT_LISTINGS_PACKAGE = "0x318d9bbbbc65be1fe53f0de1af9fd93dcbcb8d57146aba9754cf7a3b55880f5c";
+var TRADEPORT_LISTINGS_STORE = "0x90626186ce022b50109628f44ef09e183e55961972d9b1b79de53558103161ef";
 var TRADEPORT_KIOSK_LISTING_STORE = "0xbff3161b047fb8b727883838c09b08afa9e0dd0f5488bde9e99e80643da9b9e0";
 var TRADEPORT_KIOSK_TRANSFERS_STORE = "0xe0f61b6915d3fd4ec8bbe4618514e2152a82841605bfa00cde22ace434153a1b";
 var TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK = "0xa677dab85a93bd8d6845b6cc7914f3bbb334fef7fbcbe0e997b5f75b5922d106";
@@ -126,6 +129,18 @@ var TRADEPORT_PRICE_LOCK_STORE = "0x4b705de46a79b29276baf45009bc7d6f70cc0f1407f0
 var TRADEPORT_MULTI_BID_PACKAGE = "0xd1dedf8379f1781469e95cb92eed7e155c8ad141c8528c3855f59ce2a5d9d659";
 var TRADEPORT_MULTI_BID_PACKAGE_ORIGINAL = "0x53134eb544c5a0b5085e99efaf7eab13b28ad123de35d61f941f8c8c40b72033";
 var TRADEPORT_MULTI_BID_STORE = "0x8aaed7e884343fb8b222c721d02eaac2c6ae2abbb4ddcdf16cb55cf8754ee860";
+var DexConstants = {
+  commission: "0x24f5f2258ef80c0a3243088199faeb95ad50516ca1517dbd93be398d759057bb",
+  commissionManager: "0xd19a03d4ec3d12b0ce407b54eb676cc0f8e1403621deda77d9677bfcb9d738c1",
+  poolsToExclude: [
+    "0x3addbbc82866c0bbd93e51b6e2d75c0a4faaf270cc0e281d8f4de5df48bebfa4",
+    "0x19d614f421046cae90f5a3a976816063478f648087a12adc74e90ebd54dfaf19",
+    "0x514c74e28a9720366abc4a65a5688f47c72e784dbf035844d3f59059bfaed056",
+    "0x0854de4e9d64716b757b2f6f22258467f59cc1b4bc0cc64c70086549faaddedf"
+  ]
+};
+var TRADEPORT_SPONSOR_USDC_FEE_AMOUNT_PER_PERIOD = 2e7;
+var USDC_COIN_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
 var COLLECTION_IDS_WITH_ZERO_COMMISSION = [
   ""
 ];
@@ -2579,14 +2594,14 @@ var isNonKioskListing = async ({
 };
 
 // src/methods/unlistListings/addUnlistListingTxs.ts
-function addTradePortUnlistTx({ tx, listingNonce, nftType }) {
+function addLegacyTradePortUnlistTx({ tx, listingNonce, nftType }) {
   tx.moveCall({
     target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::unlist",
     arguments: [tx.object(TRADEPORT_LISTING_STORE), tx.pure.address(listingNonce)],
     typeArguments: [nftType]
   });
 }
-async function addTradePortKioskUnlistTx({
+async function addLegacyTradePortKioskUnlistTx({
   tx,
   kioskTx,
   nftTokenId,
@@ -2603,6 +2618,30 @@ async function addTradePortKioskUnlistTx({
     typeArguments: [nftType]
   });
 }
+function addTradePortUnlistTx({ tx, nftTokenId, nftType }) {
+  tx.moveCall({
+    target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::cancel_listing_without_transfer_policy`,
+    arguments: [tx.object(TRADEPORT_LISTINGS_STORE), tx.pure.id(nftTokenId)],
+    typeArguments: [nftType]
+  });
+}
+async function addKioskTradePortUnlistTx({
+  tx,
+  kioskTx,
+  nftTokenId,
+  nftType
+}) {
+  tx.moveCall({
+    target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::cancel_listing_with_transfer_policy`,
+    arguments: [
+      tx.object(TRADEPORT_LISTINGS_STORE),
+      tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      tx.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      tx.pure.id(nftTokenId)
+    ],
+    typeArguments: [nftType]
+  });
+}
 function addOriginByteUnlistTx({
   tx,
   sharedObjects,
@@ -2707,10 +2746,36 @@ async function addTradePortUnlistTxHandler(txData) {
     addOriginByteUnlistTx({ ...txData, sharedObjects });
     return;
   }
-  if (txData?.listingNonce && await isNonKioskListing({ suiClient: txData?.suiClient, listingNonce: txData?.listingNonce })) {
+  if (txData?.listingNonce?.startsWith("0::")) {
     addTradePortUnlistTx(txData);
     return;
   }
+  if (txData?.listingNonce?.startsWith("1::")) {
+    return kioskTxWrapper({
+      tx: txData?.tx,
+      kioskClient: txData?.kioskClient,
+      kioskOwner: txData?.seller,
+      kiosk: txData?.sellerKiosk,
+      shouldAllowNftUnsharedKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
+      shouldUseSharedKioskTx: false,
+      async runCommands(kioskTx) {
+        await addKioskTradePortUnlistTx({
+          ...txData,
+          kioskTx
+        });
+      }
+    });
+  }
+  if (txData?.listingNonce && await isNonKioskListing({ suiClient: txData?.suiClient, listingNonce: txData?.listingNonce })) {
+    if (txData?.isPartOfRelist) {
+      throw new Error(
+        "Cannot relist this non kiosk NFT in one transaction from legacy contract. You must unlist and list again"
+      );
+    }
+    addLegacyTradePortUnlistTx(txData);
+    return;
+  }
   if (txData?.sellerKiosk) {
     return kioskTxWrapper({
       tx: txData?.tx,
@@ -2721,7 +2786,7 @@ async function addTradePortUnlistTxHandler(txData) {
       sharedKioskState: txData?.sharedKioskState,
       shouldUseSharedKioskTx: false,
       async runCommands(kioskTx) {
-        await addTradePortKioskUnlistTx({
+        await addLegacyTradePortKioskUnlistTx({
           ...txData,
           kioskTx
         });
@@ -2744,7 +2809,7 @@ async function addTradePortUnlistTxHandler(txData) {
       }
     });
   }
-  addTradePortUnlistTx(txData);
+  addLegacyTradePortUnlistTx(txData);
 }
 async function addHyperspaceUnlistTxHandler(txData) {
   if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies) && !ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) {
@@ -3368,17 +3433,26 @@ function calculatePremium(price) {
   return BigInt(price) * PREMIUM_NOMINATOR / 10000n;
 }
 
+// src/bigNumberConfig.ts
+import { BigNumber as BigNumber2 } from "bignumber.js";
+BigNumber2.set({
+  POW_PRECISION: 64
+});
+var ZERO = new BigNumber2(0);
+var ONE = new BigNumber2(1);
+var bigNumberConfig_default = BigNumber2;
+
 // src/helpers/calculateRoyaltyFee.ts
 function calculateRoyaltyFee(transferPolicyRules, price) {
   const royaltyRule = transferPolicyRules?.filter(
-    (rule) => rule.type === "royalty_rule"
+    (rule) => rule.type === "royalty_rule" || rule.type === "kiosk_royalty_rule"
   )?.[0];
   if (!royaltyRule || !royaltyRule.amount_bp && !royaltyRule.min_amount) {
-    return 0n;
+    return ZERO;
   }
-  const royaltyFee = royaltyRule.amount_bp ? BigInt(royaltyRule.amount_bp) * price / 10000n : 0n;
-  if (royaltyRule.min_amount && BigInt(royaltyRule.min_amount) > royaltyFee) {
-    return BigInt(royaltyRule.min_amount);
+  const royaltyFee = royaltyRule.amount_bp ? new bigNumberConfig_default(royaltyRule.amount_bp).times(price).div(1e4) : ZERO;
+  if (royaltyRule.min_amount && new bigNumberConfig_default(royaltyRule.min_amount).isGreaterThan(royaltyFee)) {
+    return new bigNumberConfig_default(royaltyRule.min_amount);
   }
   return royaltyFee;
 }
@@ -3518,7 +3592,7 @@ async function buyLocks({ lockIds, transaction }, context) {
         collectionId: lock.collection_id
       })
     );
-    const royalty = calculateRoyaltyFee(transferPolicy.rules, BigInt(lock.maker_price));
+    const royalty = calculateRoyaltyFee(transferPolicy.rules, new BigNumber(lock.maker_price));
     const premiumAmount = calculatePremium(lock.maker_price);
     const [premium] = tx.splitCoins(tx.gas, [premiumAmount]);
     tx.moveCall({
@@ -3530,7 +3604,7 @@ async function buyLocks({ lockIds, transaction }, context) {
         tx.pure.id(lock.lock_id),
         tx.pure.u64(lock.maker_price),
         tx.pure.u64(marketplaceFee),
-        tx.pure.u64(royalty),
+        tx.pure.u64(royalty.toNumber()),
         tx.pure.u64(lock.expire_in),
         premium
       ]
@@ -3809,10 +3883,10 @@ var preProcessSharedBulkBuyingData = async ({
       sharedBulkBuyingDataByNftType[nftType].sharedObjects = await getSharedObjects(nftType);
       continue;
     }
-    const tradeportKioskListings = listingsByNftType[nftType]?.filter(
-      (listing) => listing.market_name === "tradeport" && listing.price && listing.listed && !(listing?.nonce && isOriginByteCollection(transferPolicies)) && listing.nft?.chain_state?.kiosk_id
+    const tradeportLegacyKioskListings = listingsByNftType[nftType]?.filter(
+      (listing) => listing.market_name === "tradeport" && !listing.nonce?.startsWith("0::") && !listing.nonce?.startsWith("1::") && listing.price && listing.listed && !(listing?.nonce && isOriginByteCollection(transferPolicies)) && listing.nft?.chain_state?.kiosk_id
     );
-    if (tradeportKioskListings.length === 0) {
+    if (tradeportLegacyKioskListings.length === 0) {
       continue;
     }
     const transferPoliciesToResolve = await getTransferPoliciesToResolve({
@@ -3824,11 +3898,11 @@ var preProcessSharedBulkBuyingData = async ({
     sharedBulkBuyingDataByNftType[nftType].transferPoliciesToResolve = transferPoliciesToResolve;
     const transferPolicyToResolve = transferPoliciesToResolve.at(0);
     const royaltyRuleToResolve = transferPolicyToResolve.rules.find(
-      (policy) => policy.moduleName === "royalty_rule" || policy.moduleName === "kiosk_royalty_rule"
+      (rule) => rule.moduleName === "royalty_rule" || rule.moduleName === "kiosk_royalty_rule"
     );
     if (royaltyRuleToResolve?.rulePackageId && royaltyRuleToResolve?.moduleName) {
       const feeTx = new Transaction8();
-      for (const listing of tradeportKioskListings) {
+      for (const listing of tradeportLegacyKioskListings) {
         feeTx.moveCall({
           target: `${royaltyRuleToResolve.rulePackageId}::${royaltyRuleToResolve.moduleName}::fee_amount`,
           arguments: [feeTx.object(transferPolicyToResolve?.id), feeTx.pure.u64(listing.price)],
@@ -3846,13 +3920,13 @@ var preProcessSharedBulkBuyingData = async ({
         if (!feeAmount && feeAmount !== 0n) {
           continue;
         }
-        sharedBulkBuyingDataByNftType[nftType].royaltyFeeAmountsByListingId[tradeportKioskListings[i].id] = feeAmount;
+        sharedBulkBuyingDataByNftType[nftType].royaltyFeeAmountsByListingId[tradeportLegacyKioskListings[i].id] = feeAmount;
       }
     }
     const batchSize = 10;
     const commissionResults = [];
-    for (let i = 0; i < tradeportKioskListings.length; i += batchSize) {
-      const batch = tradeportKioskListings.slice(i, i + batchSize);
+    for (let i = 0; i < tradeportLegacyKioskListings.length; i += batchSize) {
+      const batch = tradeportLegacyKioskListings.slice(i, i + batchSize);
       const batchPromises = batch.map(async (listing) => {
         const response = await suiClient.getDynamicFieldObject({
           parentId: TRADEPORT_KIOSK_LISTING_STORE,
@@ -3917,7 +3991,7 @@ var destroyZeroCoin = ({ tx, coin }) => {
 };
 
 // src/methods/buyListings/addBuyListingTxs.ts
-function addTradePortBuyTx({
+function addLegacyTradePortBuyTx({
   tx,
   nftType,
   listingNonce,
@@ -3953,7 +4027,7 @@ function addTradePortBuyTx({
   }
   destroyZeroCoin({ tx, coin });
 }
-var addTradeportKioskBuyTx = async ({
+var addLegacyTradeportKioskBuyTx = async ({
   tx,
   transferPolicies,
   kioskTx,
@@ -4017,6 +4091,57 @@ var addTradeportKioskBuyTx = async ({
   });
   destroyZeroCoin({ tx, coin });
 };
+async function addTradePortBuyTx({ tx, nftType, nftTokenId, price, coinToSplit }) {
+  const marketFee = new bigNumberConfig_default(price).times(TRADEPORT_LISTINGS_DEFAULT_COMMISSION_BPS).div(1e4).integerValue(bigNumberConfig_default.ROUND_DOWN).toNumber();
+  const totalAmount = new bigNumberConfig_default(price).plus(marketFee).toNumber();
+  const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(totalAmount)]);
+  if (!coin) throw new Error("Coin could not be split");
+  tx.moveCall({
+    target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::buy_listing_without_transfer_policy`,
+    arguments: [tx.object(TRADEPORT_LISTINGS_STORE), tx.pure.id(nftTokenId), tx.object(coin)],
+    typeArguments: [nftType]
+  });
+  destroyZeroCoin({ tx, coin });
+}
+async function addKioskTradePortBuyTx({
+  tx,
+  transferPolicies,
+  kioskTx,
+  nftType,
+  nftTokenId,
+  price,
+  sellerKiosk,
+  coinToSplit
+}) {
+  const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+  const marketFee = new bigNumberConfig_default(price).times(TRADEPORT_LISTINGS_DEFAULT_COMMISSION_BPS).div(1e4).integerValue(bigNumberConfig_default.ROUND_DOWN);
+  const royaltyFee = calculateRoyaltyFee(
+    getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.rules,
+    new bigNumberConfig_default(price)
+  );
+  const totalAmount = new bigNumberConfig_default(price).plus(marketFee).plus(royaltyFee).toNumber();
+  const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [tx.pure.u64(totalAmount)]);
+  if (!coin) throw new Error("Coin could not be split");
+  const transferRequest = tx.moveCall({
+    target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::buy_listing_with_transfer_policy`,
+    arguments: [
+      tx.object(TRADEPORT_LISTINGS_STORE),
+      tx.object(sellerKiosk),
+      tx.object("value" in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk),
+      tx.object("value" in kioskTx.kioskCap ? kioskTx.kioskCap.value : kioskTx.kioskCap),
+      tx.pure.id(nftTokenId),
+      tx.object(coin),
+      tx.object(transferPolicyId)
+    ],
+    typeArguments: [nftType]
+  });
+  tx.moveCall({
+    target: "0x2::transfer_policy::confirm_request",
+    arguments: [tx.object(transferPolicyId), transferRequest],
+    typeArguments: [nftType]
+  });
+  destroyZeroCoin({ tx, coin });
+}
 async function addOriginByteBuyTx({
   tx,
   sharedObjects,
@@ -4308,6 +4433,26 @@ async function addTradePortBuyTxHandler(txData) {
     await addOriginByteBuyTx({ ...txData, sharedObjects: sharedObjects2 });
     return;
   }
+  if (txData?.listingNonce?.startsWith("0::")) {
+    await addTradePortBuyTx(txData);
+    return;
+  }
+  if (txData?.listingNonce?.startsWith("1::")) {
+    return kioskTxWrapper({
+      tx: txData?.tx,
+      kioskClient: txData?.kioskClient,
+      kioskOwner: txData?.buyer,
+      kiosk: txData?.sellerKiosk,
+      shouldConvertToPersonalKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
+      async runCommands(kioskTx) {
+        await addKioskTradePortBuyTx({
+          ...txData,
+          kioskTx
+        });
+      }
+    });
+  }
   if (txData.listingNonce?.startsWith("0x")) {
     const response = await txData?.suiClient.getObject({
       id: txData.listingNonce,
@@ -4318,7 +4463,7 @@ async function addTradePortBuyTxHandler(txData) {
     }
     if (response.data.type === NON_KIOSK_LISTING_NONCE_TYPE) {
       const sharedObjects2 = txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ?? await getSharedObjects(txData?.nftType);
-      addTradePortBuyTx({ ...txData, sharedObjects: sharedObjects2 });
+      addLegacyTradePortBuyTx({ ...txData, sharedObjects: sharedObjects2 });
       return;
     }
   }
@@ -4331,7 +4476,7 @@ async function addTradePortBuyTxHandler(txData) {
       shouldConvertToPersonalKiosk: true,
       sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
-        await addTradeportKioskBuyTx({
+        await addLegacyTradeportKioskBuyTx({
           ...txData,
           kioskTx
         });
@@ -4339,7 +4484,7 @@ async function addTradePortBuyTxHandler(txData) {
     });
   }
   const sharedObjects = txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ?? await getSharedObjects(txData?.nftType);
-  addTradePortBuyTx({ ...txData, sharedObjects });
+  addLegacyTradePortBuyTx({ ...txData, sharedObjects });
 }
 async function addHyperspaceBuyTxHandler(txData) {
   if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies)) {
@@ -5368,7 +5513,7 @@ async function createLongLocks({ walletAddress, nfts }, context) {
     if (!transferPolicy) {
       throw new Error(`Missing transfer policy for ${nftType}`);
     }
-    const royalty = calculateRoyaltyFee(transferPolicy.rules, BigInt(argNft.priceInMist));
+    const royalty = calculateRoyaltyFee(transferPolicy.rules, new BigNumber(argNft.priceInMist));
     await kioskTxWrapper({
       tx,
       kioskClient: context.kioskClient,
@@ -5392,7 +5537,7 @@ async function createLongLocks({ walletAddress, nfts }, context) {
                 })
               )
             ),
-            tx.pure.u64(royalty),
+            tx.pure.u64(royalty.toNumber()),
             tx.pure.u64(premium),
             tx.pure.u64(expireIn)
           ]
@@ -5486,9 +5631,9 @@ async function createShortLocks({ nfts }, context) {
         collectionId: argNft.collectionId
       })
     );
-    const royalty = calculateRoyaltyFee(transferPolicy.rules, BigInt(argNft.priceInMist));
+    const royalty = calculateRoyaltyFee(transferPolicy.rules, new BigNumber(argNft.priceInMist));
     const [deposit] = tx.splitCoins(tx.gas, [
-      BigInt(argNft.priceInMist) + royalty + marketplaceFee
+      new BigNumber(argNft.priceInMist).plus(royalty).plus(marketplaceFee).toNumber()
     ]);
     tx.moveCall({
       target: `${TRADEPORT_PRICE_LOCK_PACKAGE}::tradeport_price_lock::create_short_lock`,
@@ -5497,7 +5642,7 @@ async function createShortLocks({ nfts }, context) {
         tx.object(TRADEPORT_PRICE_LOCK_STORE),
         tx.pure.u64(BigInt(argNft.priceInMist)),
         tx.pure.u64(marketplaceFee),
-        tx.pure.u64(royalty),
+        tx.pure.u64(royalty.toNumber()),
         tx.pure.u64(premium),
         tx.pure.u64(expireIn),
         deposit
@@ -5508,8 +5653,23 @@ async function createShortLocks({ nfts }, context) {
 }
 
 // src/methods/listNfts/listNfts.ts
-import { Transaction as Transaction18 } from "@mysten/sui/transactions";
-import { normalizeSuiAddress } from "@mysten/sui/utils";
+import { Transaction as Transaction19 } from "@mysten/sui/transactions";
+
+// src/helpers/validateMinFloorPrice.ts
+function validateMinFloorPrice({ transferPolicies, listPrice }) {
+  const transferPolicy = getNativeKioskTransferPolicies(transferPolicies)?.at(0);
+  const minFloorPrice = transferPolicy?.rules?.filter(
+    (rule) => rule?.type === "floor_price_rule"
+  )?.[0]?.floor_price;
+  if (minFloorPrice) {
+    if (listPrice < minFloorPrice) {
+      const formattedMinFloorPrice = Number(minFloorPrice) / 1e9;
+      throw new Error(
+        `NFT Transfer Policy has a miminum floor price rule. Item cannot be listed for less than ${formattedMinFloorPrice} SUI`
+      );
+    }
+  }
+}
 
 // src/methods/listNfts/addListTxs.ts
 async function addOriginByteListTx({
@@ -5565,54 +5725,35 @@ function addTradePortListTx({
   nftTokenId,
   borrowedItem,
   nftType,
-  collectionId,
   listPrice
 }) {
-  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)
+      tx.pure.u64(listPrice)
     ],
     typeArguments: [nftType]
   });
 }
-async function addTradePortKioskListTx({
+async function addKioskTradePortListTx({
   tx,
   kioskTx,
   transferPolicies,
   nftTokenId,
   nftType,
-  collectionId,
   listPrice
 }) {
-  const transferPolicy = getNativeKioskTransferPolicies(transferPolicies)?.at(0);
-  const minFloorPrice = transferPolicy?.rules?.filter(
-    (rule) => rule?.type === "floor_price_rule"
-  )?.[0]?.floor_price;
-  if (minFloorPrice) {
-    if (listPrice < minFloorPrice) {
-      const formattedMinFloorPrice = Number(minFloorPrice) / 1e9;
-      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]
   });
@@ -5657,7 +5798,7 @@ async function addTradePortListTxHandler(txData) {
       sharedKioskState: txData?.sharedKioskState,
       shouldUseSharedKioskTx: false,
       async runCommands(kioskTx) {
-        await addTradePortKioskListTx({
+        await addKioskTradePortListTx({
           ...txData,
           kioskTx
         });
@@ -5677,7 +5818,7 @@ async function addTradePortListTxHandler(txData) {
           item: txData?.nftTokenId,
           itemType: txData?.nftType
         });
-        await addTradePortKioskListTx({
+        await addKioskTradePortListTx({
           ...txData,
           kioskTx
         });
@@ -5688,43 +5829,53 @@ async function addTradePortListTxHandler(txData) {
 }
 
 // src/methods/listNfts/addRelistTxs.ts
-function addTradePortRelistTx({
+function addTradePortRelistTx({ tx, nftTokenId, nftType, listPrice }) {
+  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]
+  });
+}
+async function addKioskTradePortRelistTx({
   tx,
+  kioskTx,
+  nftTokenId,
   nftType,
-  collectionId,
-  listingNonce,
   listPrice
 }) {
-  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.pure.u64(listPrice),
-      tx.pure.u64(marketFeePrice),
-      tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS)
+      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)
     ],
     typeArguments: [nftType]
   });
 }
 function addBlueMoveRelistTx(txData) {
-  const { tx, nftTokenId, nftType, listPrice, suiClient } = txData;
+  const { tx, nftTokenId, nftType, listPrice } = txData;
   const borrowedItem = tx.moveCall({
     target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist",
     arguments: [tx.object(BLUEMOVE_MARKET_CONFIG_OBJECT), tx.pure.address(nftTokenId)],
     typeArguments: [nftType, nftType]
   });
-  addTradePortListTx({ ...txData, listPrice, borrowedItem, suiClient });
+  addTradePortListTx({ ...txData, listPrice, borrowedItem });
 }
 function addTocenRelistTx(txData) {
-  const { tx, nftTokenId, nftType, listPrice, suiClient } = txData;
+  const { tx, nftTokenId, nftType, listPrice } = txData;
   const borrowedItem = tx.moveCall({
     target: "0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::delist",
     arguments: [tx.object(TOCEN_MARKETPLACE_OBJECT), tx.pure.address(nftTokenId)],
     typeArguments: [nftType]
   });
-  addTradePortListTx({ ...txData, listPrice, borrowedItem, suiClient });
+  addTradePortListTx({ ...txData, listPrice, borrowedItem });
 }
 
 // src/methods/relistNft/relistNft.ts
@@ -5762,20 +5913,19 @@ 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
-      })) {
+      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 });
-      } else {
-        if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies) && !ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) {
-          await addTradePortUnlistTxHandler(txData);
-          await addTradePortListTxHandler({
-            ...txData,
-            listPrice
-          });
-          return;
-        }
+        return;
+      }
+      if (txData?.listingNonce?.startsWith("1::")) {
         return kioskTxWrapper({
           tx: txData?.tx,
           kioskClient: txData?.kioskClient,
@@ -5785,11 +5935,7 @@ async function relistNft({
           sharedKioskState: txData?.sharedKioskState,
           shouldUseSharedKioskTx: false,
           async runCommands(kioskTx) {
-            await addTradePortKioskUnlistTx({
-              ...txData,
-              kioskTx
-            });
-            await addTradePortKioskListTx({
+            await addKioskTradePortRelistTx({
               ...txData,
               kioskTx,
               listPrice
@@ -5797,6 +5943,8 @@ async function relistNft({
           }
         });
       }
+      await addTradePortUnlistTxHandler({ ...txData, isPartOfRelist: true });
+      await addTradePortListTxHandler({ ...txData, listPrice });
       break;
     case "hyperspace":
       await addHyperspaceUnlistTxHandler(txData);
@@ -5828,6 +5976,180 @@ async function relistNft({
   }
 }
 
+// src/helpers/swap.ts
+import { AggregatorQuoter, CoinProvider, Protocol, TradeBuilder } from "@flowx-finance/sdk";
+import {
+  coinWithBalance,
+  Transaction as Transaction18
+} from "@mysten/sui/transactions";
+import { normalizeStructTag as normalizeStructTag2, normalizeSuiAddress } from "@mysten/sui/utils";
+import ms from "ms";
+import { bcs as bcs4 } from "@mysten/sui/bcs";
+
+// src/utils/pureValues.ts
+var toDecimalValue = (value, decimals) => {
+  if (!value || decimals === void 0) return new bigNumberConfig_default(0);
+  return new bigNumberConfig_default(value).div(10 ** decimals);
+};
+var toPureValue = (value, decimals) => {
+  if (!value || decimals === void 0) return new bigNumberConfig_default(0);
+  return new bigNumberConfig_default(new bigNumberConfig_default(value).multipliedBy(10 ** decimals).toFixed(0));
+};
+
+// src/helpers/swap.ts
+var aggregatorQuoter = new AggregatorQuoter("mainnet");
+var suiCoinType = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+async function createSwapTransaction({
+  suiClient,
+  walletAddress,
+  options
+}) {
+  const tx = options?.transaction ?? new Transaction18();
+  tx.setSender(normalizeSuiAddress(walletAddress));
+  const {
+    coinInType,
+    coinInAmount = ZERO,
+    coinOutType,
+    slippage = 1,
+    ttl = "15m",
+    excludeSources = [Protocol.STEAMM, ...DexConstants.poolsToExclude],
+    rewardNftType
+  } = options ?? {};
+  if (normalizeStructTag2(coinOutType) === suiCoinType && normalizeStructTag2(coinInType) === suiCoinType) {
+    const [coin] = tx.splitCoins(tx.gas, [coinInAmount.toFixed()]);
+    return {
+      transaction: tx,
+      coinOut: coin
+    };
+  }
+  const amountInSwap = coinInAmount.minus(coinInAmount.div(100).toFixed(0));
+  const commissionAmount = coinInAmount.div(100).toFixed(0);
+  const { routes } = await aggregatorQuoter.getRoutes({
+    tokenIn: coinInType,
+    tokenOut: coinOutType ?? suiCoinType,
+    amountIn: amountInSwap.toFixed(),
+    excludeSources
+  });
+  const tradeBuilder = new TradeBuilder("mainnet", routes);
+  const trade = tradeBuilder.sender(normalizeSuiAddress(walletAddress)).slippage(slippage).deadline(Date.now() + ms(ttl)).build();
+  let coinIn;
+  if (normalizeStructTag2(coinInType) === suiCoinType) {
+    [coinIn] = tx.splitCoins(tx.gas, [
+      tx.pure.u64((BigInt(amountInSwap.toFixed()) + BigInt(commissionAmount)).toString())
+    ]);
+  } else {
+    coinIn = coinWithBalance({
+      balance: BigInt(amountInSwap.toFixed()) + BigInt(commissionAmount),
+      type: coinInType
+    })(tx);
+  }
+  const [commissionCoin] = tx.splitCoins(coinIn, [tx.pure.u64(commissionAmount.toString())]);
+  tx.moveCall({
+    target: `${DexConstants.commission}::commission::pay`,
+    arguments: [
+      tx.object(DexConstants.commissionManager),
+      tx.pure.string("swap"),
+      tx.object(commissionCoin),
+      tx.pure(bcs4.option(bcs4.String).serialize(rewardNftType).toBytes())
+    ],
+    typeArguments: [coinInType]
+  });
+  const coinOut = await trade.swap({ client: suiClient, tx, coinIn });
+  if (!coinOut) {
+    throw new Error("Swap did not return a valid coin out.");
+  }
+  if (coinOut && options?.amountToSplitFromSuiBalance > 0n) {
+    mergeSwapCoinWithSuiBalance(tx, coinOut, options?.amountToSplitFromSuiBalance);
+  }
+  return { transaction: tx, coinOut };
+}
+function mergeSwapCoinWithSuiBalance(transaction, coinToMergeInto, amountToSplitFromSuiBalance) {
+  if (coinToMergeInto && amountToSplitFromSuiBalance > 0n) {
+    const [coinFromSuiBalance] = transaction.splitCoins(transaction.gas, [
+      transaction.pure.u64(amountToSplitFromSuiBalance)
+    ]);
+    transaction.mergeCoins(coinToMergeInto, [coinFromSuiBalance]);
+  }
+}
+function transferBackExtraSwappedCoin(transaction, swapResultCoin, walletAddress) {
+  if (swapResultCoin) {
+    transaction.transferObjects([swapResultCoin], walletAddress);
+  }
+}
+async function calculateSwapInputAmountWithSlippage({
+  coinInType,
+  coinOutType,
+  coinOutAmount,
+  slippage = 0
+}) {
+  if (coinInType === coinOutType) {
+    return new bigNumberConfig_default(coinOutAmount);
+  }
+  const provider = new CoinProvider("mainnet");
+  const coinQueryResult = await provider.getCoins({
+    limit: 2,
+    coinTypes: [coinInType, coinOutType]
+  });
+  const coinIn = coinQueryResult[0];
+  const coinOut = coinQueryResult[1];
+  const exchangeRate = new bigNumberConfig_default(coinOut.derivedPriceInUSD ?? 0)?.gt(0) ? new bigNumberConfig_default(coinIn?.derivedPriceInUSD ?? 1)?.div(coinOut?.derivedPriceInUSD ?? 1) : new bigNumberConfig_default(0);
+  const amountSell = toDecimalValue(coinOutAmount.toString(), coinOut?.decimals).div(exchangeRate);
+  const slippageMultiplier = 1 + parseInt(slippage.toString() || "0", 10) / 1e6;
+  const amountWithSlippage = amountSell.times(slippageMultiplier);
+  const coinInAmount = toPureValue(amountWithSlippage, coinIn?.decimals);
+  return coinInAmount;
+}
+
+// src/methods/sponsorNftListing/addSponsorNftListingTx.ts
+import { SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID6 } from "@mysten/sui.js/utils";
+var addSponsorListingTx = async ({
+  tx,
+  nftTokenId,
+  nftType,
+  suiClient,
+  walletAddress,
+  sponsorOptions
+}) => {
+  const coinInAmount = await calculateSwapInputAmountWithSlippage({
+    coinInType: sponsorOptions?.coinInType,
+    coinOutType: USDC_COIN_TYPE,
+    coinOutAmount: new bigNumberConfig_default(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 bigNumberConfig_default(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_ID6),
+      tx.pure.id(nftTokenId),
+      tx.pure.u64(sponsorOptions?.numOfPeriods),
+      tx.object(sponsorFeeCoin)
+    ],
+    typeArguments: [nftType]
+  });
+  transferBackExtraSwappedCoin(tx, coinOut, walletAddress);
+};
+
+// src/helpers/isExpiredListing.ts
+import { normalizeSuiAddress as normalizeSuiAddress2 } from "@mysten/sui/utils";
+var isExpiredListing = (listing, walletAddress) => listing.nonce && listing.seller && normalizeSuiAddress2(listing.seller) === normalizeSuiAddress2(walletAddress);
+
 // src/methods/listNfts/listNfts.ts
 var listNfts = async ({ nfts, walletAddress }, context) => {
   const res = await gqlChainRequest({
@@ -5839,11 +6161,12 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
     throw new Error("No nfts found");
   }
   const nftsForTracking = [];
-  const tx = new Transaction18();
+  const tx = new Transaction19();
   const sharedKioskState = {
     kioskTx: void 0
   };
   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);
     }
@@ -5853,8 +6176,11 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
       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) => listing.nonce && listing.seller && normalizeSuiAddress(listing.seller) === normalizeSuiAddress(walletAddress)
+      (listing) => isExpiredListing(listing, walletAddress)
     )) {
       await relistNft({
         tx,
@@ -5863,7 +6189,7 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
         sharedKioskState,
         transferPolicies,
         nft,
-        listPrice: nfts?.find((n) => n.id === nft?.id)?.listPriceInMist,
+        listPrice: inputNft?.listPriceInMist,
         walletAddress
       });
     } else {
@@ -5877,26 +6203,36 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
         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
     });
   }
   sharedKioskState?.kioskTx?.finalize();
-  return Transaction18.from(tx);
+  return Transaction19.from(tx);
 };
 
 // src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts
-import { Transaction as Transaction19 } from "@mysten/sui/transactions";
+import { Transaction as Transaction20 } from "@mysten/sui/transactions";
 
 // src/graphql/queries/fetchNftsByKioskId.ts
 import { gql as gql18 } from "graphql-request";
@@ -6099,7 +6435,7 @@ async function getTransferPolicyForDirectTransfer(suiClient, collectionChainStat
 
 // src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts
 async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }, context) {
-  const tx = new Transaction19();
+  const tx = new Transaction20();
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchKiosksByOwner,
@@ -6265,11 +6601,11 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
     }
   }
   sharedKioskState?.kioskTx?.finalize();
-  return Transaction19.from(tx);
+  return Transaction20.from(tx);
 }
 
 // src/methods/placeCollectionBids/placeCollectionBids.ts
-import { Transaction as Transaction20 } from "@mysten/sui/transactions";
+import { Transaction as Transaction21 } from "@mysten/sui/transactions";
 
 // src/graphql/queries/fetchCollectionsById.ts
 import { gql as gql19 } from "graphql-request";
@@ -6326,12 +6662,12 @@ async function addTradePortPlaceNftBidTxHandler(txData) {
     expireAt,
     coinToSplit
   } = txData;
-  let bcs4;
+  let bcs5;
   if (nftTokenId && isDynamicCollection(collectionId)) {
     if (!bcsHex) {
       throw new Error(`No BCS found for token ${nftTokenId}`);
     }
-    bcs4 = fromHex(bcsHex);
+    bcs5 = fromHex(bcsHex);
   }
   let multiBidChainId;
   let expiredBids;
@@ -6393,7 +6729,7 @@ async function addTradePortPlaceNftBidTxHandler(txData) {
         arguments: [multiBidChainId]
       }) : void 0,
       tx.pure.option("id", nftTokenId ? normalizeSuiObjectId5(nftTokenId) : void 0),
-      tx.pure.option("vector<u8>", bcs4 ? [...bcs4] : void 0),
+      tx.pure.option("vector<u8>", bcs5 ? [...bcs5] : void 0),
       tx.pure.option("u64", expireAt?.getTime()),
       tx.pure.u64(price),
       ...transferPolicy ? [tx.object(transferPolicy.id)] : [],
@@ -6544,11 +6880,11 @@ var placeCollectionBids = async ({ collections, walletAddress, multiBidId, multi
   if (swapResultCoin) {
     tx.transferObjects([swapResultCoin], walletAddress);
   }
-  return Transaction20.from(tx);
+  return Transaction21.from(tx);
 };
 
 // src/methods/placeNftBids/placeNftBids.ts
-import { Transaction as Transaction21 } from "@mysten/sui/transactions";
+import { Transaction as Transaction22 } from "@mysten/sui/transactions";
 var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx: existingTx }, context) => {
   const tx = deserializeOrCreateTxBlock({ existingTx });
   const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
@@ -6598,11 +6934,11 @@ var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx
   if (swapResultCoin) {
     tx.transferObjects([swapResultCoin], walletAddress);
   }
-  return Transaction21.from(tx);
+  return Transaction22.from(tx);
 };
 
 // src/methods/removeCollectionBids/removeCollectionBids.ts
-import { Transaction as Transaction22 } from "@mysten/sui/transactions";
+import { Transaction as Transaction23 } from "@mysten/sui/transactions";
 
 // src/methods/removeCollectionBids/addRemoveCollectionBidsTxs.ts
 import { normalizeSuiObjectId as normalizeSuiObjectId6 } from "@mysten/sui/utils";
@@ -6710,7 +7046,7 @@ var removeCollectionBids = async ({ bidIds, tx: existingTx }, context) => {
     throw new Error("No bids found");
   }
   const bidsForTracking = [];
-  const tx = existingTx ? Transaction22.from(existingTx) : new Transaction22();
+  const tx = existingTx ? Transaction23.from(existingTx) : new Transaction23();
   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);
@@ -6758,11 +7094,11 @@ var removeCollectionBids = async ({ bidIds, tx: existingTx }, context) => {
       bidder: bid?.bidder
     });
   }
-  return Transaction22.from(tx);
+  return Transaction23.from(tx);
 };
 
 // src/methods/removeNftBids/removeNftBids.ts
-import { Transaction as Transaction23 } from "@mysten/sui/transactions";
+import { Transaction as Transaction24 } from "@mysten/sui/transactions";
 var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -6773,7 +7109,7 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
     throw new Error("No bids found");
   }
   const bidsForTracking = [];
-  const tx = existingTx ? Transaction23.from(existingTx) : new Transaction23();
+  const tx = existingTx ? Transaction24.from(existingTx) : new Transaction24();
   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);
@@ -6818,11 +7154,11 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
       bidder: bid?.bidder
     });
   }
-  return Transaction23.from(tx);
+  return Transaction24.from(tx);
 };
 
 // src/methods/transferNfts/transferNfts.ts
-import { Transaction as Transaction24 } from "@mysten/sui/transactions";
+import { Transaction as Transaction25 } from "@mysten/sui/transactions";
 var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context) => {
   if (addLeadingZerosAfter0x(recipientAddress) === addLeadingZerosAfter0x(walletAddress)) {
     throw new Error("Cannot transfer to self");
@@ -6840,7 +7176,7 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
   }
   const nftsForTracking = [];
   const nftsToTransferDirectly = [];
-  const tx = new Transaction24();
+  const tx = new Transaction25();
   const sharedKioskState = {
     kioskTx: void 0
   };
@@ -6943,11 +7279,11 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
     context.suiClient
   );
   sharedKioskState?.kioskTx?.finalize();
-  return Transaction24.from(tx);
+  return Transaction25.from(tx);
 };
 
 // src/methods/unlistListings/unlistListings.ts
-import { Transaction as Transaction25 } from "@mysten/sui/transactions";
+import { Transaction as Transaction26 } from "@mysten/sui/transactions";
 var unlistListings = async ({ listingIds, walletAddress }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -6958,7 +7294,7 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
     throw new Error("No listings found");
   }
   const listingsForTracking = [];
-  const tx = new Transaction25();
+  const tx = new Transaction26();
   const sharedKioskState = {
     kioskTx: void 0
   };
@@ -7027,12 +7363,12 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
     });
   }
   sharedKioskState?.kioskTx?.finalize();
-  return Transaction25.from(tx);
+  return Transaction26.from(tx);
 };
 
 // src/methods/withdrawProfitsFromKiosks/withdrawProfitsFromKiosks.ts
 import { KioskTransaction as KioskTransaction2 } from "@mysten/kiosk";
-import { Transaction as Transaction26 } from "@mysten/sui/transactions";
+import { Transaction as Transaction27 } from "@mysten/sui/transactions";
 async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -7052,7 +7388,7 @@ async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   if (kiosksWithProfit.length === 0) {
     throw new Error(`No kiosks with profit to withdraw found for ${walletAddress}`);
   }
-  const tx = new Transaction26();
+  const tx = new Transaction27();
   try {
     for (const kiosk of kiosksWithProfit) {
       let kioskTx;
@@ -7098,9 +7434,57 @@ async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   } catch (err) {
     console.log("err", err);
   }
-  return Transaction26.from(tx);
+  return Transaction27.from(tx);
 }
 
+// src/methods/sponsorNftListing/sponsorNftListing.ts
+import { Transaction as Transaction28 } from "@mysten/sui/transactions";
+
+// src/graphql/queries/fetchNftCollectionChainState.ts
+import { gql as gql21 } from "graphql-request";
+var fetchNftCollectionChainState = gql21`
+	query fetchNftCollectionChainState($nftTokenId: String!) {
+		nfts(where: { token_id: { _eq: $nftTokenId } }) {
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;
+
+// src/methods/sponsorNftListing/sponsorNftListing.ts
+var sponsorNftListing = async ({ nftTokenId, walletAddress, options }, context) => {
+  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 Transaction28();
+  await addSponsorListingTx({
+    tx,
+    suiClient: context.suiClient,
+    nftTokenId,
+    nftType,
+    walletAddress,
+    sponsorOptions: options
+  });
+  return Transaction28.from(tx);
+};
+
 // src/SuiTradingClient.ts
 var SuiTradingClient = class {
   constructor({ apiUser, apiKey, suiNodeUrl, graphQLClient }) {
@@ -7434,6 +7818,15 @@ var SuiTradingClient = class {
   async updateMultiBid(args) {
     return updateMultiBid(args);
   }
+  async sponsorNftListing(args) {
+    const context = {
+      apiUser: this.apiUser,
+      apiKey: this.apiKey,
+      suiClient: this.suiClient,
+      kioskClient: this.kioskClient
+    };
+    return sponsorNftListing(args, context);
+  }
 };
 var SuiTradingClient_default = SuiTradingClient;
 export {