@tradeport/sui-trading-sdk 0.4.64 → 0.4.65

package/dist/index.mjs

@@ -142,6 +142,16 @@ var TRADEPORT_NFT_STRATEGY_PACKAGE_ID = "0xb7386fc8c6e64ea2b0079e293592b57e98498
 var TRADEPORT_NFT_STRATEGY_MANAGER_ID = "0xfb58ee62b3a62a8150f871da950dfdf923cd0d97b153caf99b5219cd4ddda5bd";
 var TRADEPORT_POOL_REGISTRY_ID = "0xcd0a614c4cbbf173f59dee2602c43a1717f283215ed7a0bb1d55d786af16fbcd";
 var TRADEPORT_POOL_VERSIONED_ID = "0x0309b66202e9aaf470081fffee7ffc0fbd50e3b7400d4f56fd06502e4dbbd676";
+var DexConstants = {
+  commission: "0x24f5f2258ef80c0a3243088199faeb95ad50516ca1517dbd93be398d759057bb",
+  commissionManager: "0xd19a03d4ec3d12b0ce407b54eb676cc0f8e1403621deda77d9677bfcb9d738c1",
+  poolsToExclude: [
+    "0x3addbbc82866c0bbd93e51b6e2d75c0a4faaf270cc0e281d8f4de5df48bebfa4",
+    "0x19d614f421046cae90f5a3a976816063478f648087a12adc74e90ebd54dfaf19",
+    "0x514c74e28a9720366abc4a65a5688f47c72e784dbf035844d3f59059bfaed056",
+    "0x0854de4e9d64716b757b2f6f22258467f59cc1b4bc0cc64c70086549faaddedf"
+  ]
+};
 var USDC_COIN_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
 var COLLECTION_IDS_WITH_ZERO_COMMISSION = [
   ""
@@ -3572,6 +3582,16 @@ var getCollectionChainState = async (collectionId) => {
   });
   return res?.collections?.[0]?.chain_state;
 };
+var getCollectionChainStateByFtType = async (ftType) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchCollectionChainStateByFtType,
+    variables: {
+      ftType
+    }
+  });
+  return res?.collections_by_ft_type?.[0]?.chain_state;
+};
 
 // src/methods/applyFtStrategy/applyFtStrategy.ts
 async function applyFtStrategy({
@@ -3606,105 +3626,12 @@ async function applyFtStrategy({
   return tx;
 }
 
-// src/methods/applyNftStrategy/applyNftStrategy.ts
-import { Transaction as Transaction5 } from "@mysten/sui/transactions";
-
-// src/graphql/queries/fetchCollectionFloorListingForMarket.ts
-import { gql as gql13 } from "graphql-request";
-var fetchCollectionFloorListingsForMarket = gql13`
-	query fetchCollectionFloorListingsForMarket(
-		$collectionId: uuid!
-		$marketAddress: String!
-		$totalPrice: numeric
-	) {
-		listings(
-			where: {
-				collection_id: { _eq: $collectionId }
-				listed: { _eq: true }
-				market_name: { _eq: "tradeport" }
-				seller: { _neq: $marketAddress }
-				nonce: { _like: "1::0x%" }
-				price: { _lte: $totalPrice }
-			}
-			order_by: [{ price: asc_nulls_last }, { block_height: asc }, { tx_index: asc }]
-		) {
-			id
-			price
-			nft {
-				token_id
-				delegated_owner
-			}
-		}
-	}
-`;
-
-// src/methods/applyNftStrategy/applyNftStrategy.ts
-async function applyTradeportNftStrategy({
-  collectionId,
-  strategyFtType,
-  tx: existingTx
-}) {
-  const tx = existingTx ?? new Transaction5();
-  const chainState = await getCollectionChainState(collectionId);
-  const nftStrategies = chainState?.nft_strategies ?? {};
-  const nftStrategyKeys = Object.keys(nftStrategies);
-  if (nftStrategyKeys.length === 0) {
-    throw new Error("No NFT strategies found for collection");
-  }
-  strategyFtType = strategyFtType ?? nftStrategyKeys[0];
-  if (!nftStrategyKeys.includes(strategyFtType)) {
-    throw new Error(`Specified FT type ${strategyFtType} is not supported for this collection`);
-  }
-  const transferPolicy = getNativeKioskTransferPolicies(chainState?.transfer_policies ?? [])?.at(0);
-  if (!transferPolicy) {
-    throw new Error("No transfer policy found for collection");
-  }
-  const nftType = chainState?.nft_type;
-  let suiBalance = BigInt(
-    nftStrategies[strategyFtType].sui_balance ?? 0n
-  );
-  const result = await gqlChainRequest({
-    chain: "sui",
-    query: fetchCollectionFloorListingsForMarket,
-    variables: {
-      collectionId,
-      marketAddress: TRADEPORT_NFT_STRATEGY_MANAGER_ID,
-      totalPrice: suiBalance.toString()
-    }
-  });
-  if ((result?.listings?.length ?? 0) === 0) {
-    throw new Error(
-      `No floor listing found for collection with price bellow or equal to ${suiBalance} MIST`
-    );
-  }
-  for (const floorListing of result.listings) {
-    suiBalance -= BigInt(floorListing.price);
-    if (suiBalance < 0n) {
-      break;
-    }
-    tx.moveCall({
-      target: `${TRADEPORT_NFT_STRATEGY_PACKAGE_ID}::tradeport_nft_strategy::apply_tradeport_nft_strategy_confirm_request`,
-      typeArguments: [nftType, strategyFtType],
-      arguments: [
-        tx.object(TRADEPORT_NFT_STRATEGY_MANAGER_ID),
-        tx.object(nftStrategies[strategyFtType].kiosk_id),
-        tx.object(TRADEPORT_LISTINGS_STORE),
-        tx.object(TRADEPORT_ORDERBOOK_STORE),
-        tx.object(floorListing.nft.delegated_owner),
-        tx.object(floorListing.nft.token_id),
-        tx.object(transferPolicy.id)
-      ]
-    });
-  }
-  return tx;
-}
-
 // src/methods/buyListings/buyListings.ts
 import { Transaction as Transaction7 } from "@mysten/sui/transactions";
 
 // src/graphql/queries/fetchListingsById.ts
-import { gql as gql14 } from "graphql-request";
-var fetchListingsById = gql14`
+import { gql as gql13 } from "graphql-request";
+var fetchListingsById = gql13`
 	query fetchListingsById($listingIds: [uuid!]) {
 		listings(where: { id: { _in: $listingIds } }) {
 			id
@@ -3743,6 +3670,29 @@ var addThirdPartyTxFee = async (tx, price) => {
   );
 };
 
+// src/helpers/deserializeOrCreateTxBlock.ts
+import { Transaction as Transaction5 } from "@mysten/sui/transactions";
+var deserializeOrCreateTxBlock = ({
+  existingTx
+}) => {
+  if (typeof existingTx === "string") {
+    return Transaction5.from(existingTx);
+  }
+  return existingTx ?? new Transaction5();
+};
+
+// src/helpers/extractSwapResultCoin.ts
+var extractSwapResultCoinFromTxBlock = (txBlock) => {
+  if (!txBlock) return void 0;
+  const tx = typeof txBlock === "string" ? JSON.parse(txBlock) : txBlock?.getData();
+  const commands = tx.commands ?? [];
+  const index = commands.findIndex(
+    (cmd) => cmd?.MoveCall?.module === "universal_router" && cmd?.MoveCall?.function === "settle"
+  );
+  if (index === -1) return void 0;
+  return { $kind: "Result", Result: index };
+};
+
 // src/helpers/kiosk/preProcessSharedBulkBuyingData.ts
 import { bcs as bcs2 } from "@mysten/sui/bcs";
 import { Transaction as Transaction6 } from "@mysten/sui/transactions";
@@ -3848,8 +3798,8 @@ var preProcessSharedBulkBuyingData = async ({
 import { bcs as bcs3 } from "@mysten/sui/bcs";
 
 // src/graphql/queries/fetchCommissionByListingId.ts
-import { gql as gql15 } from "graphql-request";
-var fetchCommissionByNftContractId = gql15`
+import { gql as gql14 } from "graphql-request";
+var fetchCommissionByNftContractId = gql14`
 	query fetchCommissionByNftContractId($nftContractId: uuid!) {
 		commissions(where: { contract_id: { _eq: $nftContractId } }) {
 			is_custodial
@@ -4599,7 +4549,8 @@ var buyListings = async ({
     throw new Error("No listings found");
   }
   const listingsForTracking = [];
-  const tx = existingTx ?? new Transaction7();
+  const tx = deserializeOrCreateTxBlock({ existingTx });
+  const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
   const tocenTokenIds = [];
   let tocenNftType = "";
   let tocenTotalPrice = 0;
@@ -4644,7 +4595,7 @@ var buyListings = async ({
       sellerKiosk: listing.nft?.chain_state?.kiosk_id,
       collectionId: listing?.nft?.collection_id,
       nftContractId: listing?.nft?.contract_id,
-      coinToSplit,
+      coinToSplit: swapResultCoin ? swapResultCoin : coinToSplit,
       marketFeeDecimalPercent,
       beforeResolveKioskTransferRequest,
       sharedKioskState,
@@ -4693,6 +4644,9 @@ var buyListings = async ({
     });
   }
   sharedKioskState?.kioskTx?.finalize();
+  if (swapResultCoin) {
+    tx.transferObjects([swapResultCoin], walletAddress);
+  }
   if (tocenTokenIds?.length > 0) {
     addTocenBuyTxHandler({
       tx,
@@ -4701,7 +4655,7 @@ var buyListings = async ({
       price: tocenTotalPrice
     });
   }
-  return tx;
+  return Transaction7.from(tx);
 };
 
 // src/methods/cancelMultiBid/cancelMultiBid.ts
@@ -4825,8 +4779,8 @@ async function cancelMultiBid({ multiBidId }) {
 import { Transaction as Transaction9 } from "@mysten/sui/transactions";
 
 // src/graphql/queries/fetchAccountKiosks.ts
-import { gql as gql16 } from "graphql-request";
-var fetchAccountKiosks = gql16`
+import { gql as gql15 } from "graphql-request";
+var fetchAccountKiosks = gql15`
 	query fetchAccountKiosks($accountAddress: String!) {
 		kiosks: kiosks_by_owner_address(owner_address: $accountAddress) {
 			id
@@ -5295,22 +5249,17 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
   return Transaction10.from(tx);
 };
 
-// src/methods/createMultiBid/createMultiBid.ts
-import { Transaction as Transaction12 } from "@mysten/sui/transactions";
-
 // src/methods/updateMultiBid/updateMultiBid.ts
-import { Transaction as Transaction11 } from "@mysten/sui/transactions";
 async function updateMultiBid({
-  walletAddress,
   multiBidId,
   name,
   amount,
   amountToWithdraw,
   tx: existingTx,
-  multiBidChainId,
-  coinToSplit
-}, context) {
-  const tx = existingTx ?? new Transaction11();
+  multiBidChainId
+}) {
+  const tx = deserializeOrCreateTxBlock({ existingTx });
+  const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
   if (!multiBidChainId) {
     const { chain_id: chainId, cancelled_at } = (await gqlChainRequest({
       chain: "sui",
@@ -5325,7 +5274,7 @@ async function updateMultiBid({
     }
     multiBidChainId = chainId;
   }
-  const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [amount ?? 0n]);
+  const [coin] = tx.splitCoins(swapResultCoin ? swapResultCoin : tx.gas, [amount ?? 0n]);
   tx.moveCall({
     target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::update_multi_bid`,
     arguments: [
@@ -5346,7 +5295,7 @@ async function createMultiBid({
   amount,
   tx: existingTx
 }) {
-  const tx = existingTx ?? new Transaction12();
+  const tx = deserializeOrCreateTxBlock({ existingTx });
   const multiBidChainId = tx.moveCall({
     target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::create_multi_bid`,
     arguments: [tx.object(TRADEPORT_MULTI_BID_STORE), tx.pure.option("string", name)]
@@ -5364,11 +5313,7 @@ async function createMultiBid({
 }
 
 // src/methods/listNfts/listNfts.ts
-import { Transaction as Transaction13 } from "@mysten/sui/transactions";
-
-// src/helpers/isExpiredListing.ts
-import { normalizeSuiAddress } from "@mysten/sui/utils";
-var isExpiredListing = (listing, walletAddress) => listing.nonce && listing.seller && normalizeSuiAddress(listing.seller) === normalizeSuiAddress(walletAddress);
+import { Transaction as Transaction12 } from "@mysten/sui/transactions";
 
 // src/helpers/validateMinFloorPrice.ts
 function validateMinFloorPrice({ transferPolicies, listPrice }) {
@@ -5697,16 +5642,328 @@ async function relistNft({
   }
 }
 
+// src/methods/swapCoins/swapCoins.ts
+import {
+  AggregatorQuoter,
+  CoinProvider,
+  Protocol,
+  TradeBuilder
+} from "@flowx-finance/sdk";
+import { coinWithBalance, Transaction as Transaction11 } from "@mysten/sui/transactions";
+import { normalizeStructTag as normalizeStructTag2, normalizeSuiAddress, SUI_TYPE_ARG } from "@mysten/sui/utils";
+import ms from "ms";
+
+// 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/methods/swapCoins/swapCoins.ts
+async function swapCoins({
+  walletAddress,
+  coinInType,
+  coinInAmount,
+  coinOutType,
+  slippage = 1e3,
+  // 0.1%
+  ttl = "5m",
+  excludeSources = [Protocol.STEAMM, Protocol.BOLT],
+  routes,
+  commission,
+  tx: existingTx
+}, { suiClient, defiRouterUrl }) {
+  const inAmount = BigInt(coinInAmount);
+  const tx = existingTx ?? new Transaction11();
+  coinInType = normalizeStructTag2(coinInType);
+  coinOutType = normalizeStructTag2(coinOutType);
+  walletAddress = normalizeSuiAddress(walletAddress);
+  tx.setSenderIfNotSet(normalizeSuiAddress(walletAddress));
+  if (inAmount === 0n) {
+    const zeroCoin = tx.moveCall({
+      target: "0x2::coin::zero",
+      typeArguments: [coinOutType]
+    });
+    return {
+      tx,
+      coinOut: zeroCoin
+    };
+  }
+  if (coinInType === coinOutType) {
+    const getCoin = coinWithBalance({
+      type: coinInType,
+      balance: inAmount
+    });
+    return {
+      tx,
+      coinOut: getCoin(tx)
+    };
+  }
+  const types = await getAffectedNftAndFtTypes(coinInType, coinOutType);
+  const { feeAndReward, amountToSwap } = calculateSwapAmounts(types.length, inAmount);
+  if (!routes) {
+    routes = (await buildSwapRoutes(
+      {
+        walletAddress,
+        coinInType,
+        coinOutType,
+        amountToSwap,
+        excludeSources,
+        commission
+      },
+      { defiRouterUrl }
+    )).routes;
+  }
+  const tradeBuilder = new TradeBuilder("mainnet", routes);
+  if (commission) {
+    tradeBuilder.commission(commission);
+  }
+  const trade = tradeBuilder.sender(walletAddress).slippage(slippage).deadline(Date.now() + ms(ttl)).build();
+  const coinOut = await trade.swap({ client: suiClient, tx });
+  let suiFeeAndRewardCoin;
+  if (coinInType === normalizeStructTag2(SUI_TYPE_ARG)) {
+    suiFeeAndRewardCoin = tx.splitCoins(tx.gas, [
+      tx.pure.u64(feeAndReward)
+    ])[0];
+  } else {
+    const suiFeeAndRewardRoutes = await buildSwapRoutes(
+      {
+        walletAddress,
+        coinInType,
+        coinOutType: SUI_TYPE_ARG,
+        amountToSwap: feeAndReward,
+        excludeSources
+      },
+      { defiRouterUrl }
+    );
+    const suiFeeTradeBuilder = new TradeBuilder("mainnet", suiFeeAndRewardRoutes.routes);
+    const suiFeeTrade = suiFeeTradeBuilder.sender(walletAddress).slippage(slippage).deadline(Date.now() + ms(ttl)).build();
+    suiFeeAndRewardCoin = await suiFeeTrade.swap({ client: suiClient, tx });
+  }
+  if (types.length > 0) {
+    if (types.length > 2) {
+      throw new Error("Unexpected affected types count greater than 2");
+    }
+    let usedSuiCoin = suiFeeAndRewardCoin;
+    if (types.length === 2) {
+      const suiFeeAndRewardCoinBalance = tx.moveCall({
+        target: "0x2::coin::value",
+        typeArguments: [SUI_TYPE_ARG],
+        arguments: [suiFeeAndRewardCoin]
+      });
+      const halfSuiCoinAmount = tx.moveCall({
+        target: "0x2::math::divide_and_round_up",
+        arguments: [suiFeeAndRewardCoinBalance, tx.pure.u64(2)]
+      });
+      const [coin] = tx.splitCoins(usedSuiCoin, [halfSuiCoinAmount]);
+      usedSuiCoin = coin;
+    }
+    for (const data of types) {
+      const { nftType, ftType, type } = data;
+      switch (type) {
+        case "liquidNft": {
+          tx.moveCall({
+            target: `${DexConstants.commission}::commission::pay`,
+            arguments: [
+              tx.object(DexConstants.commissionManager),
+              tx.pure.string("swap"),
+              usedSuiCoin,
+              tx.pure.option("string", nftType)
+            ],
+            typeArguments: [SUI_TYPE_ARG]
+          });
+          break;
+        }
+        case "nftStrategy": {
+          const suiFeeAndRewardCoinBalance = tx.moveCall({
+            target: "0x2::coin::value",
+            typeArguments: [SUI_TYPE_ARG],
+            arguments: [usedSuiCoin]
+          });
+          const feeAmount = tx.moveCall({
+            target: "0x2::math::divide_and_round_up",
+            arguments: [suiFeeAndRewardCoinBalance, tx.pure.u64(4)]
+          });
+          const [feeCoin] = tx.splitCoins(usedSuiCoin, [feeAmount]);
+          tx.moveCall({
+            target: `${DexConstants.commission}::commission::pay`,
+            arguments: [
+              tx.object(DexConstants.commissionManager),
+              tx.pure.string("swap"),
+              feeCoin,
+              tx.pure.option("string", void 0)
+            ],
+            typeArguments: [SUI_TYPE_ARG]
+          });
+          tx.moveCall({
+            target: `${TRADEPORT_NFT_STRATEGY_PACKAGE_ID}::tradeport_nft_strategy::reward_strategy`,
+            arguments: [
+              tx.object(TRADEPORT_NFT_STRATEGY_MANAGER_ID),
+              usedSuiCoin
+              //  3/4 retained coin for reward
+            ],
+            typeArguments: [nftType, ftType]
+          });
+          break;
+        }
+        default: {
+          throw new Error(`Unexpected type ${type}`);
+        }
+      }
+      usedSuiCoin = suiFeeAndRewardCoin;
+    }
+  } else {
+    tx.moveCall({
+      target: `${DexConstants.commission}::commission::pay`,
+      arguments: [
+        tx.object(DexConstants.commissionManager),
+        tx.pure.string("swap"),
+        suiFeeAndRewardCoin,
+        tx.pure.option("string", void 0)
+      ],
+      typeArguments: [SUI_TYPE_ARG]
+    });
+  }
+  return {
+    tx,
+    coinOut
+  };
+}
+async function calculateAmountToSwap({
+  coinInType,
+  coinOutType,
+  coinInAmount
+}) {
+  const types = await getAffectedNftAndFtTypes(coinInType, coinOutType);
+  const { amountToSwap } = calculateSwapAmounts(types.length, BigInt(coinInAmount));
+  return amountToSwap;
+}
+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?.find(
+    (coin) => normalizeStructTag2(coin.coinType) === normalizeStructTag2(coinInType)
+  );
+  const coinOut = coinQueryResult?.find(
+    (coin) => normalizeStructTag2(coin.coinType) === normalizeStructTag2(coinOutType)
+  );
+  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;
+}
+async function buildSwapRoutes(options, { defiRouterUrl }) {
+  const aggregatorQuoter = new AggregatorQuoter("mainnet");
+  const routes = await aggregatorQuoter.getRoutes({
+    tokenIn: options.coinInType,
+    tokenOut: options.coinOutType,
+    amountIn: options.amountToSwap.toString(),
+    commission: options.commission,
+    excludeSources: options.excludeSources
+  });
+  if (defiRouterUrl && options.walletAddress) {
+    await makeDefiRouterRequest(`${defiRouterUrl}/start`, {
+      walletId: options.walletAddress,
+      coinTypeIn: options.coinInType,
+      coinTypeOut: options.coinOutType,
+      amountIn: options.amountToSwap.toString()
+    });
+  }
+  return routes;
+}
+function calculateSwapAmounts(affectedTypesCount, inAmount) {
+  const feeAndReward = affectedTypesCount > 0 ? BigInt(affectedTypesCount) * inAmount / 25n : inAmount / 100n;
+  const amountToSwap = inAmount - feeAndReward;
+  if (amountToSwap <= 0n) {
+    throw new Error("Amount to swap is too small");
+  }
+  return { feeAndReward, amountToSwap };
+}
+async function getAffectedNftAndFtTypes(coinInType, coinOutType) {
+  const normalizedSuiType = normalizeStructTag2(SUI_TYPE_ARG);
+  const coinTypes = [coinInType, coinOutType].filter((type) => type !== normalizedSuiType);
+  const types = await Promise.all(
+    coinTypes.map(async (type) => {
+      const chainState = await getCollectionChainStateByFtType(type);
+      return chainState ? {
+        nftType: chainState.nft_type,
+        ftType: type,
+        type: chainState.ft_type ? "liquidNft" : "nftStrategy"
+      } : void 0;
+    })
+  );
+  return types.filter(Boolean);
+}
+async function makeDefiRouterRequest(url, body, defaultResponse = void 0) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      console.warn(`DeFi router request failed with status ${response.status}`);
+      return defaultResponse;
+    }
+    if (response.headers.get("Content-Type")?.includes("application/json")) {
+      return await response.json();
+    }
+    return defaultResponse;
+  } catch (error) {
+    console.warn(`DeFi router request error: ${error.message}`);
+    return defaultResponse;
+  }
+}
+
 // src/methods/sponsorNftListing/addSponsorNftListingTx.ts
-import { coinWithBalance } from "@mysten/sui/transactions";
 var addSponsorListingTx = async ({
   tx,
   nftTokenId,
   nftType,
-  sponsorOptions
+  suiClient,
+  walletAddress,
+  sponsorOptions,
+  defiRouterUrl
 }) => {
-  const totalFee = new bigNumberConfig_default(sponsorOptions?.usdcFeeAmountPerPeriod)?.times(sponsorOptions?.numOfPeriods).toString();
-  const sponsorCoin = sponsorOptions.coinToSplit ? tx.splitCoins(sponsorOptions.coinToSplit, [tx.pure.u64(totalFee)])[0] : coinWithBalance({ type: USDC_COIN_TYPE, balance: BigInt(totalFee) });
+  const coinInAmount = sponsorOptions?.coinInAmount ?? await calculateSwapInputAmountWithSlippage({
+    coinInType: sponsorOptions?.coinInType,
+    coinOutType: USDC_COIN_TYPE,
+    coinOutAmount: new bigNumberConfig_default(sponsorOptions?.usdcFeeAmountPerPeriod)?.times(sponsorOptions?.numOfPeriods).toString(),
+    slippage: sponsorOptions?.slippage
+  });
+  const { coinOut } = await swapCoins(
+    {
+      walletAddress,
+      coinInType: sponsorOptions?.coinInType,
+      coinInAmount: coinInAmount.toString(),
+      coinOutType: USDC_COIN_TYPE,
+      slippage: sponsorOptions?.slippage,
+      tx
+    },
+    { suiClient, defiRouterUrl }
+  );
+  const [sponsorFeeCoin] = tx.splitCoins(coinOut, [
+    tx.pure.u64(
+      new bigNumberConfig_default(sponsorOptions?.usdcFeeAmountPerPeriod)?.times(sponsorOptions?.numOfPeriods).toString()
+    )
+  ]);
   tx.moveCall({
     target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::add_sponsored_listing`,
     arguments: [
@@ -5714,14 +5971,19 @@ var addSponsorListingTx = async ({
       tx.object.clock(),
       tx.pure.id(nftTokenId),
       tx.pure.u64(sponsorOptions?.numOfPeriods),
-      tx.object(sponsorCoin)
+      tx.object(sponsorFeeCoin)
     ],
     typeArguments: [nftType]
   });
+  tx.transferObjects([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, tx: existingTx }, context) => {
+var listNfts = async ({ nfts, walletAddress }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchNftsWithListingsById,
@@ -5731,7 +5993,7 @@ var listNfts = async ({ nfts, walletAddress, tx: existingTx }, context) => {
     throw new Error("No nfts found");
   }
   const nftsForTracking = [];
-  const tx = existingTx ?? new Transaction13();
+  const tx = new Transaction12();
   const sharedKioskState = {
     kioskTx: void 0
   };
@@ -5781,9 +6043,12 @@ var listNfts = async ({ nfts, walletAddress, tx: existingTx }, context) => {
     if (inputNft?.sponsorOptions?.shouldSponsor) {
       await addSponsorListingTx({
         tx,
+        suiClient: context.suiClient,
         nftTokenId: nft?.token_id,
         nftType,
-        sponsorOptions: inputNft?.sponsorOptions
+        walletAddress,
+        sponsorOptions: inputNft?.sponsorOptions,
+        defiRouterUrl: context.defiRouterUrl
       });
     }
     nftsForTracking.push({
@@ -5796,15 +6061,15 @@ var listNfts = async ({ nfts, walletAddress, tx: existingTx }, context) => {
     });
   }
   sharedKioskState?.kioskTx?.finalize();
-  return tx;
+  return tx instanceof Transaction12 ? tx : Transaction12.from(tx);
 };
 
 // src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts
-import { Transaction as Transaction14 } from "@mysten/sui/transactions";
+import { Transaction as Transaction13 } from "@mysten/sui/transactions";
 
 // src/graphql/queries/fetchNftsByKioskId.ts
-import { gql as gql17 } from "graphql-request";
-var fetchNftsByKioskId = gql17`
+import { gql as gql16 } from "graphql-request";
+var fetchNftsByKioskId = gql16`
 	query fetchNftsByKioskId($jsonFilter: jsonb) {
 		nfts(where: { chain_state: { _contains: $jsonFilter } }) {
 			id
@@ -5825,7 +6090,7 @@ var fetchNftsByKioskId = gql17`
 		}
 	}
 `;
-var fetchBulkNftsByKioskId = gql17`
+var fetchBulkNftsByKioskId = gql16`
 	query fetchNftsByKioskId($where: nfts_bool_exp) {
 		nfts(where: $where) {
 			id
@@ -5848,8 +6113,8 @@ var fetchBulkNftsByKioskId = gql17`
 `;
 
 // src/graphql/queries/fetchTransferPoliciesByType.ts
-import { gql as gql18 } from "graphql-request";
-var fetchTransferPoliciesByType = gql18`
+import { gql as gql17 } from "graphql-request";
+var fetchTransferPoliciesByType = gql17`
 	query fetchTransferPoliciesByType($type: String!) {
 		transfer_policies_by_type(type: $type) {
 			id
@@ -6008,7 +6273,7 @@ async function getTransferPolicyForDirectTransfer(suiClient, collectionChainStat
 
 // src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts
 async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }, context) {
-  const tx = new Transaction14();
+  const tx = new Transaction13();
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchKiosksByOwner,
@@ -6174,15 +6439,15 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
     }
   }
   sharedKioskState?.kioskTx?.finalize();
-  return Transaction14.from(tx);
+  return Transaction13.from(tx);
 }
 
 // src/methods/placeCollectionBids/placeCollectionBids.ts
-import { Transaction as Transaction15 } from "@mysten/sui/transactions";
+import { Transaction as Transaction14 } from "@mysten/sui/transactions";
 
 // src/graphql/queries/fetchCollectionsById.ts
-import { gql as gql19 } from "graphql-request";
-var fetchCollectionsById = gql19`
+import { gql as gql18 } from "graphql-request";
+var fetchCollectionsById = gql18`
 	query fetchCollectionsById($collectionIds: [uuid!]) {
 		collections(where: { id: { _in: $collectionIds } }) {
 			id
@@ -6192,7 +6457,7 @@ var fetchCollectionsById = gql19`
 		}
 	}
 `;
-var fetchCollectionsByIdWithOneNft = gql19`
+var fetchCollectionsByIdWithOneNft = gql18`
 	query fetchCollectionsByIdWithOneNft($collectionIds: [uuid!]) {
 		collections(where: { id: { _in: $collectionIds } }) {
 			id
@@ -6210,7 +6475,7 @@ var fetchCollectionsByIdWithOneNft = gql19`
 		}
 	}
 `;
-var fetchCollectionsBySlug = gql19`
+var fetchCollectionsBySlug = gql18`
 	query fetchCollectionsBySlug($slug: String!) {
 		collections(where: { slug: { _eq: $slug } }) {
 			id
@@ -6332,8 +6597,8 @@ function isDynamicCollection(collectionId) {
 }
 
 // src/graphql/queries/fetchCollectionFloorListings.ts
-import { gql as gql20 } from "graphql-request";
-var fetchCollectionFloorListings = gql20`
+import { gql as gql19 } from "graphql-request";
+var fetchCollectionFloorListings = gql19`
 	query fetchCollectionFloorListings($collectionId: uuid!) {
 		listings(
 			where: { collection_id: { _eq: $collectionId }, listed: { _eq: true }, nft: {} }
@@ -6392,14 +6657,7 @@ async function addOriginByteCollectionBidTx({
 }
 
 // src/methods/placeCollectionBids/placeCollectionBids.ts
-var placeCollectionBids = async ({
-  collections,
-  walletAddress,
-  multiBidId,
-  multiBidChainId,
-  tx: existingTx,
-  coinToSplit
-}, context) => {
+var placeCollectionBids = async ({ collections, walletAddress, multiBidId, multiBidChainId, tx: existingTx }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchCollectionsByIdWithOneNft,
@@ -6409,7 +6667,8 @@ var placeCollectionBids = async ({
     throw new Error("No collection found");
   }
   const collectionsForTracking = [];
-  const tx = existingTx ?? new Transaction15();
+  const tx = deserializeOrCreateTxBlock({ existingTx });
+  const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
   for (const collection of res.collections) {
     const nftType = getNftType({
       collectionId: collection?.id,
@@ -6429,7 +6688,7 @@ var placeCollectionBids = async ({
       multiBidId,
       multiBidChainId,
       expireAt: collections?.find((c) => c.id === collection?.id)?.expireAt,
-      coinToSplit
+      coinToSplit: swapResultCoin
     };
     const numOfBids = collections?.find((c) => c.id === collection?.id)?.numOfBids;
     if (isOriginByteCollection(txData?.transferPolicies) && !ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) {
@@ -6456,13 +6715,17 @@ var placeCollectionBids = async ({
       bidder: walletAddress
     });
   }
-  return tx;
+  if (swapResultCoin) {
+    tx.transferObjects([swapResultCoin], walletAddress);
+  }
+  return Transaction14.from(tx);
 };
 
 // src/methods/placeNftBids/placeNftBids.ts
-import { Transaction as Transaction16 } from "@mysten/sui/transactions";
-var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx: existingTx, coinToSplit }, context) => {
-  const tx = existingTx ?? new Transaction16();
+import { Transaction as Transaction15 } from "@mysten/sui/transactions";
+var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx: existingTx }, context) => {
+  const tx = deserializeOrCreateTxBlock({ existingTx });
+  const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchNftsById,
@@ -6496,7 +6759,7 @@ var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx
       multiBidId,
       multiBidChainId,
       expireAt: bid?.expireAt,
-      coinToSplit
+      coinToSplit: swapResultCoin
     };
     await addTradePortPlaceNftBidTxHandler(txData);
     nftsForTracking.push({
@@ -6506,11 +6769,14 @@ var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx
       bidder: walletAddress
     });
   }
-  return tx;
+  if (swapResultCoin) {
+    tx.transferObjects([swapResultCoin], walletAddress);
+  }
+  return Transaction15.from(tx);
 };
 
 // src/methods/removeCollectionBids/removeCollectionBids.ts
-import { Transaction as Transaction17 } from "@mysten/sui/transactions";
+import { Transaction as Transaction16 } from "@mysten/sui/transactions";
 
 // src/methods/removeCollectionBids/addRemoveCollectionBidsTxs.ts
 import { normalizeSuiObjectId as normalizeSuiObjectId7 } from "@mysten/sui/utils";
@@ -6618,7 +6884,7 @@ var removeCollectionBids = async ({ bidIds, tx: existingTx }, context) => {
     throw new Error("No bids found");
   }
   const bidsForTracking = [];
-  const tx = existingTx ? Transaction17.from(existingTx) : new Transaction17();
+  const tx = existingTx ? Transaction16.from(existingTx) : new Transaction16();
   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);
@@ -6666,11 +6932,11 @@ var removeCollectionBids = async ({ bidIds, tx: existingTx }, context) => {
       bidder: bid?.bidder
     });
   }
-  return Transaction17.from(tx);
+  return Transaction16.from(tx);
 };
 
 // src/methods/removeNftBids/removeNftBids.ts
-import { Transaction as Transaction18 } from "@mysten/sui/transactions";
+import { Transaction as Transaction17 } from "@mysten/sui/transactions";
 var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -6681,7 +6947,7 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
     throw new Error("No bids found");
   }
   const bidsForTracking = [];
-  const tx = existingTx ? Transaction18.from(existingTx) : new Transaction18();
+  const tx = existingTx ? Transaction17.from(existingTx) : new Transaction17();
   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);
@@ -6726,61 +6992,11 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
       bidder: bid?.bidder
     });
   }
-  return Transaction18.from(tx);
-};
-
-// src/methods/sponsorNftListing/sponsorNftListing.ts
-import { Transaction as Transaction19 } 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 ({
-  tx: existingTx,
-  nftTokenId,
-  options
-}) => {
-  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 = existingTx ?? new Transaction19();
-  await addSponsorListingTx({
-    tx,
-    nftTokenId,
-    nftType,
-    sponsorOptions: options
-  });
-  return tx;
+  return Transaction17.from(tx);
 };
 
 // src/methods/transferNfts/transferNfts.ts
-import { Transaction as Transaction20 } from "@mysten/sui/transactions";
+import { Transaction as Transaction18 } from "@mysten/sui/transactions";
 var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context) => {
   if (addLeadingZerosAfter0x(recipientAddress) === addLeadingZerosAfter0x(walletAddress)) {
     throw new Error("Cannot transfer to self");
@@ -6798,7 +7014,7 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
   }
   const nftsForTracking = [];
   const nftsToTransferDirectly = [];
-  const tx = new Transaction20();
+  const tx = new Transaction18();
   const sharedKioskState = {
     kioskTx: void 0
   };
@@ -6901,11 +7117,11 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
     context.suiClient
   );
   sharedKioskState?.kioskTx?.finalize();
-  return Transaction20.from(tx);
+  return Transaction18.from(tx);
 };
 
 // src/methods/unlistListings/unlistListings.ts
-import { Transaction as Transaction21 } from "@mysten/sui/transactions";
+import { Transaction as Transaction19 } from "@mysten/sui/transactions";
 var unlistListings = async ({ listingIds, walletAddress }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -6916,7 +7132,7 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
     throw new Error("No listings found");
   }
   const listingsForTracking = [];
-  const tx = new Transaction21();
+  const tx = new Transaction19();
   const sharedKioskState = {
     kioskTx: void 0
   };
@@ -6985,12 +7201,12 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
     });
   }
   sharedKioskState?.kioskTx?.finalize();
-  return Transaction21.from(tx);
+  return Transaction19.from(tx);
 };
 
 // src/methods/withdrawProfitsFromKiosks/withdrawProfitsFromKiosks.ts
 import { KioskTransaction as KioskTransaction2 } from "@mysten/kiosk";
-import { Transaction as Transaction22 } from "@mysten/sui/transactions";
+import { Transaction as Transaction20 } from "@mysten/sui/transactions";
 async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -7010,7 +7226,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 Transaction22();
+  const tx = new Transaction20();
   try {
     for (const kiosk of kiosksWithProfit) {
       let kioskTx;
@@ -7056,7 +7272,149 @@ async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   } catch (err) {
     console.log("err", err);
   }
-  return Transaction22.from(tx);
+  return Transaction20.from(tx);
+}
+
+// src/methods/sponsorNftListing/sponsorNftListing.ts
+import { Transaction as Transaction21 } from "@mysten/sui/transactions";
+
+// src/graphql/queries/fetchNftCollectionChainState.ts
+import { gql as gql20 } from "graphql-request";
+var fetchNftCollectionChainState = gql20`
+	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 Transaction21();
+  await addSponsorListingTx({
+    tx,
+    suiClient: context.suiClient,
+    nftTokenId,
+    nftType,
+    walletAddress,
+    sponsorOptions: options,
+    defiRouterUrl: context.defiRouterUrl
+  });
+  return tx instanceof Transaction21 ? tx : Transaction21.from(tx);
+};
+
+// src/methods/applyNftStrategy/applyNftStrategy.ts
+import { Transaction as Transaction22 } from "@mysten/sui/transactions";
+
+// src/graphql/queries/fetchCollectionFloorListingForMarket.ts
+import { gql as gql21 } from "graphql-request";
+var fetchCollectionFloorListingsForMarket = gql21`
+	query fetchCollectionFloorListingsForMarket(
+		$collectionId: uuid!
+		$marketAddress: String!
+		$totalPrice: numeric
+	) {
+		listings(
+			where: {
+				collection_id: { _eq: $collectionId }
+				listed: { _eq: true }
+				market_name: { _eq: "tradeport" }
+				seller: { _neq: $marketAddress }
+				nonce: { _like: "1::0x%" }
+				price: { _lte: $totalPrice }
+			}
+			order_by: [{ price: asc_nulls_last }, { block_height: asc }, { tx_index: asc }]
+		) {
+			id
+			price
+			nft {
+				token_id
+				delegated_owner
+			}
+		}
+	}
+`;
+
+// src/methods/applyNftStrategy/applyNftStrategy.ts
+async function applyTradeportNftStrategy({
+  collectionId,
+  strategyFtType,
+  tx: existingTx
+}) {
+  const tx = existingTx ?? new Transaction22();
+  const chainState = await getCollectionChainState(collectionId);
+  const nftStrategies = chainState?.nft_strategies ?? {};
+  const nftStrategyKeys = Object.keys(nftStrategies);
+  if (nftStrategyKeys.length === 0) {
+    throw new Error("No NFT strategies found for collection");
+  }
+  strategyFtType = strategyFtType ?? nftStrategyKeys[0];
+  if (!nftStrategyKeys.includes(strategyFtType)) {
+    throw new Error(`Specified FT type ${strategyFtType} is not supported for this collection`);
+  }
+  const transferPolicy = getNativeKioskTransferPolicies(chainState?.transfer_policies ?? [])?.at(0);
+  if (!transferPolicy) {
+    throw new Error("No transfer policy found for collection");
+  }
+  const nftType = chainState?.nft_type;
+  let suiBalance = BigInt(
+    nftStrategies[strategyFtType].sui_balance ?? 0n
+  );
+  const result = await gqlChainRequest({
+    chain: "sui",
+    query: fetchCollectionFloorListingsForMarket,
+    variables: {
+      collectionId,
+      marketAddress: TRADEPORT_NFT_STRATEGY_MANAGER_ID,
+      totalPrice: suiBalance.toString()
+    }
+  });
+  if ((result?.listings?.length ?? 0) === 0) {
+    throw new Error(
+      `No floor listing found for collection with price bellow or equal to ${suiBalance} MIST`
+    );
+  }
+  for (const floorListing of result.listings) {
+    suiBalance -= BigInt(floorListing.price);
+    if (suiBalance < 0n) {
+      break;
+    }
+    tx.moveCall({
+      target: `${TRADEPORT_NFT_STRATEGY_PACKAGE_ID}::tradeport_nft_strategy::apply_tradeport_nft_strategy_confirm_request`,
+      typeArguments: [nftType, strategyFtType],
+      arguments: [
+        tx.object(TRADEPORT_NFT_STRATEGY_MANAGER_ID),
+        tx.object(nftStrategies[strategyFtType].kiosk_id),
+        tx.object(TRADEPORT_LISTINGS_STORE),
+        tx.object(TRADEPORT_ORDERBOOK_STORE),
+        tx.object(floorListing.nft.delegated_owner),
+        tx.object(floorListing.nft.token_id),
+        tx.object(transferPolicy.id)
+      ]
+    });
+  }
+  return tx;
 }
 
 // src/SuiTradingClient.ts
@@ -7066,14 +7424,14 @@ var SuiTradingClient = class {
     apiKey,
     apiVercelId,
     apiUrl,
-    tradeportRouterUrl,
+    defiRouterUrl,
     suiNodeUrl,
     graphQLClient
   }) {
     this.allowedApiUsersForUnsharedKiosksMigration = ["tradeport.xyz", "mercato.xyz"];
     this.apiUser = apiUser;
     this.apiKey = apiKey;
-    this.tradeportRouterUrl = tradeportRouterUrl;
+    this.defiRouterUrl = defiRouterUrl ?? "https://api.indexer.xyz/router";
     this.suiClient = createSuiClient_default(suiNodeUrl ?? getFullnodeUrl("mainnet"));
     this.kioskClient = createKioskClient_default(this.suiClient);
     if (graphQLClient) {
@@ -7087,31 +7445,31 @@ var SuiTradingClient = class {
       ...apiVercelId && { "x-vercel-id": apiVercelId }
     });
   }
-  async buyListings(args) {
+  async buyListings({ listingIds, walletAddress, tx }) {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
-    return buyListings(args, context);
+    return buyListings({ listingIds, walletAddress, tx }, context);
   }
-  async listNfts({ nfts, walletAddress, tx }) {
+  async listNfts({ nfts, walletAddress }) {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
-    return listNfts({ nfts, walletAddress, tx }, context);
+    return listNfts({ nfts, walletAddress }, context);
   }
   async unlistListings({ listingIds, walletAddress }) {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7121,7 +7479,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7130,7 +7488,7 @@ var SuiTradingClient = class {
   async removeNftBids({ bidIds, tx }) {
     const context = {
       apiUser: this.apiUser,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       apiKey: this.apiKey,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
@@ -7141,7 +7499,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7160,7 +7518,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7186,7 +7544,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7262,7 +7620,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7272,7 +7630,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7282,7 +7640,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7298,7 +7656,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7318,7 +7676,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7331,7 +7689,7 @@ var SuiTradingClient = class {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
-      tradeportRouterUrl: this.tradeportRouterUrl,
+      defiRouterUrl: this.defiRouterUrl,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
@@ -7344,13 +7702,17 @@ var SuiTradingClient = class {
     return cancelMultiBid(args);
   }
   async updateMultiBid(args) {
-    return updateMultiBid(args, {
-      suiClient: this.suiClient,
-      tradeportRouterUrl: this.tradeportRouterUrl
-    });
+    return updateMultiBid(args);
   }
   async sponsorNftListing(args) {
-    return sponsorNftListing(args);
+    const context = {
+      apiUser: this.apiUser,
+      apiKey: this.apiKey,
+      defiRouterUrl: this.defiRouterUrl,
+      suiClient: this.suiClient,
+      kioskClient: this.kioskClient
+    };
+    return sponsorNftListing(args, context);
   }
   async applyFtStrategy(args) {
     return applyFtStrategy(args);
@@ -7358,6 +7720,15 @@ var SuiTradingClient = class {
   async applyTradeportNftStrategy(args) {
     return applyTradeportNftStrategy(args);
   }
+  async swapCoins(args) {
+    return swapCoins(args, { suiClient: this.suiClient, defiRouterUrl: this.defiRouterUrl });
+  }
+  async buildSwapRoutes(args) {
+    return buildSwapRoutes(args, { defiRouterUrl: this.defiRouterUrl });
+  }
+  async calculateAmountToSwap(args) {
+    return calculateAmountToSwap(args);
+  }
 };
 var SuiTradingClient_default = SuiTradingClient;
 export {