@tradeport/sui-trading-sdk 0.4.39 → 0.4.41

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,14 +17,22 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   SuiTradingClient: () => SuiTradingClient_default
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/SuiTradingClient.ts
 var import_client2 = require("@mysten/sui/client");
@@ -139,8 +149,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";
@@ -152,6 +165,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 = [
   ""
 ];
@@ -2603,14 +2628,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,
@@ -2627,6 +2652,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,
@@ -2731,10 +2780,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,
@@ -2745,7 +2820,7 @@ async function addTradePortUnlistTxHandler(txData) {
       sharedKioskState: txData?.sharedKioskState,
       shouldUseSharedKioskTx: false,
       async runCommands(kioskTx) {
-        await addTradePortKioskUnlistTx({
+        await addLegacyTradePortKioskUnlistTx({
           ...txData,
           kioskTx
         });
@@ -2768,7 +2843,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))) {
@@ -3392,17 +3467,26 @@ function calculatePremium(price) {
   return BigInt(price) * PREMIUM_NOMINATOR / 10000n;
 }
 
+// src/bigNumberConfig.ts
+var import_bignumber = require("bignumber.js");
+import_bignumber.BigNumber.set({
+  POW_PRECISION: 64
+});
+var ZERO = new import_bignumber.BigNumber(0);
+var ONE = new import_bignumber.BigNumber(1);
+var bigNumberConfig_default = import_bignumber.BigNumber;
+
 // 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;
 }
@@ -3542,7 +3626,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({
@@ -3554,7 +3638,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
       ]
@@ -3833,10 +3917,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({
@@ -3848,11 +3932,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 import_transactions8.Transaction();
-      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)],
@@ -3870,13 +3954,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,
@@ -3941,7 +4025,7 @@ var destroyZeroCoin = ({ tx, coin }) => {
 };
 
 // src/methods/buyListings/addBuyListingTxs.ts
-function addTradePortBuyTx({
+function addLegacyTradePortBuyTx({
   tx,
   nftType,
   listingNonce,
@@ -3977,7 +4061,7 @@ function addTradePortBuyTx({
   }
   destroyZeroCoin({ tx, coin });
 }
-var addTradeportKioskBuyTx = async ({
+var addLegacyTradeportKioskBuyTx = async ({
   tx,
   transferPolicies,
   kioskTx,
@@ -4041,6 +4125,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,
@@ -4332,6 +4467,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,
@@ -4342,7 +4497,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;
     }
   }
@@ -4355,7 +4510,7 @@ async function addTradePortBuyTxHandler(txData) {
       shouldConvertToPersonalKiosk: true,
       sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
-        await addTradeportKioskBuyTx({
+        await addLegacyTradeportKioskBuyTx({
           ...txData,
           kioskTx
         });
@@ -4363,7 +4518,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)) {
@@ -5392,7 +5547,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,
@@ -5416,7 +5571,7 @@ async function createLongLocks({ walletAddress, nfts }, context) {
                 })
               )
             ),
-            tx.pure.u64(royalty),
+            tx.pure.u64(royalty.toNumber()),
             tx.pure.u64(premium),
             tx.pure.u64(expireIn)
           ]
@@ -5510,9 +5665,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`,
@@ -5521,7 +5676,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
@@ -5532,8 +5687,23 @@ async function createShortLocks({ nfts }, context) {
 }
 
 // src/methods/listNfts/listNfts.ts
-var import_transactions18 = require("@mysten/sui/transactions");
-var import_utils10 = require("@mysten/sui/utils");
+var import_transactions19 = require("@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({
@@ -5589,54 +5759,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]
   });
@@ -5681,7 +5832,7 @@ async function addTradePortListTxHandler(txData) {
       sharedKioskState: txData?.sharedKioskState,
       shouldUseSharedKioskTx: false,
       async runCommands(kioskTx) {
-        await addTradePortKioskListTx({
+        await addKioskTradePortListTx({
           ...txData,
           kioskTx
         });
@@ -5701,7 +5852,7 @@ async function addTradePortListTxHandler(txData) {
           item: txData?.nftTokenId,
           itemType: txData?.nftType
         });
-        await addTradePortKioskListTx({
+        await addKioskTradePortListTx({
           ...txData,
           kioskTx
         });
@@ -5712,43 +5863,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
@@ -5786,20 +5947,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,
@@ -5809,11 +5969,7 @@ async function relistNft({
           sharedKioskState: txData?.sharedKioskState,
           shouldUseSharedKioskTx: false,
           async runCommands(kioskTx) {
-            await addTradePortKioskUnlistTx({
-              ...txData,
-              kioskTx
-            });
-            await addTradePortKioskListTx({
+            await addKioskTradePortRelistTx({
               ...txData,
               kioskTx,
               listPrice
@@ -5821,6 +5977,8 @@ async function relistNft({
           }
         });
       }
+      await addTradePortUnlistTxHandler({ ...txData, isPartOfRelist: true });
+      await addTradePortListTxHandler({ ...txData, listPrice });
       break;
     case "hyperspace":
       await addHyperspaceUnlistTxHandler(txData);
@@ -5852,6 +6010,177 @@ async function relistNft({
   }
 }
 
+// src/helpers/swap.ts
+var import_sdk = require("@flowx-finance/sdk");
+var import_transactions18 = require("@mysten/sui/transactions");
+var import_utils10 = require("@mysten/sui/utils");
+var import_ms = __toESM(require("ms"));
+var import_bcs4 = require("@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 import_sdk.AggregatorQuoter("mainnet");
+var suiCoinType = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+async function createSwapTransaction({
+  suiClient,
+  walletAddress,
+  options
+}) {
+  const tx = options?.transaction ?? new import_transactions18.Transaction();
+  tx.setSender((0, import_utils10.normalizeSuiAddress)(walletAddress));
+  const {
+    coinInType,
+    coinInAmount = ZERO,
+    coinOutType,
+    slippage = 1,
+    ttl = "15m",
+    excludeSources = [import_sdk.Protocol.STEAMM, ...DexConstants.poolsToExclude],
+    rewardNftType
+  } = options ?? {};
+  if ((0, import_utils10.normalizeStructTag)(coinOutType) === suiCoinType && (0, import_utils10.normalizeStructTag)(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 import_sdk.TradeBuilder("mainnet", routes);
+  const trade = tradeBuilder.sender((0, import_utils10.normalizeSuiAddress)(walletAddress)).slippage(slippage).deadline(Date.now() + (0, import_ms.default)(ttl)).build();
+  let coinIn;
+  if ((0, import_utils10.normalizeStructTag)(coinInType) === suiCoinType) {
+    [coinIn] = tx.splitCoins(tx.gas, [
+      tx.pure.u64((BigInt(amountInSwap.toFixed()) + BigInt(commissionAmount)).toString())
+    ]);
+  } else {
+    coinIn = (0, import_transactions18.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(import_bcs4.bcs.option(import_bcs4.bcs.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 import_sdk.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
+var import_utils11 = require("@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(import_utils11.SUI_CLOCK_OBJECT_ID),
+      tx.pure.id(nftTokenId),
+      tx.pure.u64(sponsorOptions?.numOfPeriods),
+      tx.object(sponsorFeeCoin)
+    ],
+    typeArguments: [nftType]
+  });
+  transferBackExtraSwappedCoin(tx, coinOut, walletAddress);
+};
+
+// src/helpers/isExpiredListing.ts
+var import_utils12 = require("@mysten/sui/utils");
+var isExpiredListing = (listing, walletAddress) => listing.nonce && listing.seller && (0, import_utils12.normalizeSuiAddress)(listing.seller) === (0, import_utils12.normalizeSuiAddress)(walletAddress);
+
 // src/methods/listNfts/listNfts.ts
 var listNfts = async ({ nfts, walletAddress }, context) => {
   const res = await gqlChainRequest({
@@ -5863,11 +6192,12 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
     throw new Error("No nfts found");
   }
   const nftsForTracking = [];
-  const tx = new import_transactions18.Transaction();
+  const tx = new import_transactions19.Transaction();
   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);
     }
@@ -5877,8 +6207,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 && (0, import_utils10.normalizeSuiAddress)(listing.seller) === (0, import_utils10.normalizeSuiAddress)(walletAddress)
+      (listing) => isExpiredListing(listing, walletAddress)
     )) {
       await relistNft({
         tx,
@@ -5887,7 +6220,7 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
         sharedKioskState,
         transferPolicies,
         nft,
-        listPrice: nfts?.find((n) => n.id === nft?.id)?.listPriceInMist,
+        listPrice: inputNft?.listPriceInMist,
         walletAddress
       });
     } else {
@@ -5901,26 +6234,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 import_transactions18.Transaction.from(tx);
+  return import_transactions19.Transaction.from(tx);
 };
 
 // src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts
-var import_transactions19 = require("@mysten/sui/transactions");
+var import_transactions20 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchNftsByKioskId.ts
 var import_graphql_request19 = require("graphql-request");
@@ -6123,7 +6466,7 @@ async function getTransferPolicyForDirectTransfer(suiClient, collectionChainStat
 
 // src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts
 async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }, context) {
-  const tx = new import_transactions19.Transaction();
+  const tx = new import_transactions20.Transaction();
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchKiosksByOwner,
@@ -6289,11 +6632,11 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
     }
   }
   sharedKioskState?.kioskTx?.finalize();
-  return import_transactions19.Transaction.from(tx);
+  return import_transactions20.Transaction.from(tx);
 }
 
 // src/methods/placeCollectionBids/placeCollectionBids.ts
-var import_transactions20 = require("@mysten/sui/transactions");
+var import_transactions21 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchCollectionsById.ts
 var import_graphql_request20 = require("graphql-request");
@@ -6334,7 +6677,7 @@ var fetchCollectionsBySlug = import_graphql_request20.gql`
 `;
 
 // src/methods/placeNftBids/addPlaceNftBidTxs.ts
-var import_utils11 = require("@mysten/sui/utils");
+var import_utils13 = require("@mysten/sui/utils");
 async function addTradePortPlaceNftBidTxHandler(txData) {
   if (isOriginByteCollection(txData?.transferPolicies) && !ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) {
     throw new Error("OriginByte bidding not supported currently");
@@ -6350,12 +6693,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 = (0, import_utils11.fromHex)(bcsHex);
+    bcs5 = (0, import_utils13.fromHex)(bcsHex);
   }
   let multiBidChainId;
   let expiredBids;
@@ -6411,13 +6754,13 @@ async function addTradePortPlaceNftBidTxHandler(txData) {
     arguments: [
       tx.object(TRADEPORT_MULTI_BID_STORE),
       tx.pure.u64(nftTokenId ? 1 : 0),
-      multiBidChainId ? typeof multiBidChainId === "string" ? tx.pure.option("id", (0, import_utils11.normalizeSuiObjectId)(multiBidChainId)) : tx.moveCall({
+      multiBidChainId ? typeof multiBidChainId === "string" ? tx.pure.option("id", (0, import_utils13.normalizeSuiObjectId)(multiBidChainId)) : tx.moveCall({
         target: "0x1::option::some",
         typeArguments: ["0x2::object::ID"],
         arguments: [multiBidChainId]
       }) : void 0,
-      tx.pure.option("id", nftTokenId ? (0, import_utils11.normalizeSuiObjectId)(nftTokenId) : void 0),
-      tx.pure.option("vector<u8>", bcs4 ? [...bcs4] : void 0),
+      tx.pure.option("id", nftTokenId ? (0, import_utils13.normalizeSuiObjectId)(nftTokenId) : 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)] : [],
@@ -6568,11 +6911,11 @@ var placeCollectionBids = async ({ collections, walletAddress, multiBidId, multi
   if (swapResultCoin) {
     tx.transferObjects([swapResultCoin], walletAddress);
   }
-  return import_transactions20.Transaction.from(tx);
+  return import_transactions21.Transaction.from(tx);
 };
 
 // src/methods/placeNftBids/placeNftBids.ts
-var import_transactions21 = require("@mysten/sui/transactions");
+var import_transactions22 = require("@mysten/sui/transactions");
 var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx: existingTx }, context) => {
   const tx = deserializeOrCreateTxBlock({ existingTx });
   const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
@@ -6622,14 +6965,14 @@ var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx
   if (swapResultCoin) {
     tx.transferObjects([swapResultCoin], walletAddress);
   }
-  return import_transactions21.Transaction.from(tx);
+  return import_transactions22.Transaction.from(tx);
 };
 
 // src/methods/removeCollectionBids/removeCollectionBids.ts
-var import_transactions22 = require("@mysten/sui/transactions");
+var import_transactions23 = require("@mysten/sui/transactions");
 
 // src/methods/removeCollectionBids/addRemoveCollectionBidsTxs.ts
-var import_utils12 = require("@mysten/sui/utils");
+var import_utils14 = require("@mysten/sui/utils");
 function addTradeportRemoveCollectionBidTx({
   tx,
   nftType,
@@ -6685,7 +7028,7 @@ function addBluemoveKioskRemoveCollectionBidTx({
 async function addTradePortRemoveCollectionBidTxHandler(txData) {
   const bidType = await getObjectType({
     suiClient: txData?.suiClient,
-    objectId: (0, import_utils12.normalizeSuiObjectId)(txData?.bidNonce)
+    objectId: (0, import_utils14.normalizeSuiObjectId)(txData?.bidNonce)
   });
   if (isSingleBid(bidType)) {
     await addSingleBidRemoveNftBidTx(txData);
@@ -6705,7 +7048,7 @@ async function addTradePortRemoveCollectionBidTxHandler(txData) {
 async function addBluemoveRemoveCollectionBidTxHandler(txData) {
   const bidType = await getObjectType({
     suiClient: txData?.suiClient,
-    objectId: (0, import_utils12.normalizeSuiObjectId)(txData?.bidNonce)
+    objectId: (0, import_utils14.normalizeSuiObjectId)(txData?.bidNonce)
   });
   if (isOriginByteBid(bidType)) {
     const sharedObjects = await getSharedObjects(txData?.nftType);
@@ -6734,7 +7077,7 @@ var removeCollectionBids = async ({ bidIds, tx: existingTx }, context) => {
     throw new Error("No bids found");
   }
   const bidsForTracking = [];
-  const tx = existingTx ? import_transactions22.Transaction.from(existingTx) : new import_transactions22.Transaction();
+  const tx = existingTx ? import_transactions23.Transaction.from(existingTx) : new import_transactions23.Transaction();
   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);
@@ -6782,11 +7125,11 @@ var removeCollectionBids = async ({ bidIds, tx: existingTx }, context) => {
       bidder: bid?.bidder
     });
   }
-  return import_transactions22.Transaction.from(tx);
+  return import_transactions23.Transaction.from(tx);
 };
 
 // src/methods/removeNftBids/removeNftBids.ts
-var import_transactions23 = require("@mysten/sui/transactions");
+var import_transactions24 = require("@mysten/sui/transactions");
 var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -6797,7 +7140,7 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
     throw new Error("No bids found");
   }
   const bidsForTracking = [];
-  const tx = existingTx ? import_transactions23.Transaction.from(existingTx) : new import_transactions23.Transaction();
+  const tx = existingTx ? import_transactions24.Transaction.from(existingTx) : new import_transactions24.Transaction();
   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);
@@ -6842,11 +7185,11 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
       bidder: bid?.bidder
     });
   }
-  return import_transactions23.Transaction.from(tx);
+  return import_transactions24.Transaction.from(tx);
 };
 
 // src/methods/transferNfts/transferNfts.ts
-var import_transactions24 = require("@mysten/sui/transactions");
+var import_transactions25 = require("@mysten/sui/transactions");
 var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context) => {
   if (addLeadingZerosAfter0x(recipientAddress) === addLeadingZerosAfter0x(walletAddress)) {
     throw new Error("Cannot transfer to self");
@@ -6864,7 +7207,7 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
   }
   const nftsForTracking = [];
   const nftsToTransferDirectly = [];
-  const tx = new import_transactions24.Transaction();
+  const tx = new import_transactions25.Transaction();
   const sharedKioskState = {
     kioskTx: void 0
   };
@@ -6967,11 +7310,11 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
     context.suiClient
   );
   sharedKioskState?.kioskTx?.finalize();
-  return import_transactions24.Transaction.from(tx);
+  return import_transactions25.Transaction.from(tx);
 };
 
 // src/methods/unlistListings/unlistListings.ts
-var import_transactions25 = require("@mysten/sui/transactions");
+var import_transactions26 = require("@mysten/sui/transactions");
 var unlistListings = async ({ listingIds, walletAddress }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -6982,7 +7325,7 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
     throw new Error("No listings found");
   }
   const listingsForTracking = [];
-  const tx = new import_transactions25.Transaction();
+  const tx = new import_transactions26.Transaction();
   const sharedKioskState = {
     kioskTx: void 0
   };
@@ -7051,12 +7394,12 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
     });
   }
   sharedKioskState?.kioskTx?.finalize();
-  return import_transactions25.Transaction.from(tx);
+  return import_transactions26.Transaction.from(tx);
 };
 
 // src/methods/withdrawProfitsFromKiosks/withdrawProfitsFromKiosks.ts
 var import_kiosk5 = require("@mysten/kiosk");
-var import_transactions26 = require("@mysten/sui/transactions");
+var import_transactions27 = require("@mysten/sui/transactions");
 async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -7076,7 +7419,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 import_transactions26.Transaction();
+  const tx = new import_transactions27.Transaction();
   try {
     for (const kiosk of kiosksWithProfit) {
       let kioskTx;
@@ -7122,9 +7465,57 @@ async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   } catch (err) {
     console.log("err", err);
   }
-  return import_transactions26.Transaction.from(tx);
+  return import_transactions27.Transaction.from(tx);
 }
 
+// src/methods/sponsorNftListing/sponsorNftListing.ts
+var import_transactions28 = require("@mysten/sui/transactions");
+
+// src/graphql/queries/fetchNftCollectionChainState.ts
+var import_graphql_request22 = require("graphql-request");
+var fetchNftCollectionChainState = import_graphql_request22.gql`
+	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 import_transactions28.Transaction();
+  await addSponsorListingTx({
+    tx,
+    suiClient: context.suiClient,
+    nftTokenId,
+    nftType,
+    walletAddress,
+    sponsorOptions: options
+  });
+  return import_transactions28.Transaction.from(tx);
+};
+
 // src/SuiTradingClient.ts
 var SuiTradingClient = class {
   constructor({ apiUser, apiKey, suiNodeUrl, graphQLClient }) {
@@ -7458,6 +7849,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;
 // Annotate the CommonJS export names for ESM import in node: