@tradeport/sui-trading-sdk 0.4.15 → 0.4.16

package/dist/index.js

@@ -1319,7 +1319,10 @@ var hasPersonalKioskRule = (transferPolicies) => getNativeKioskTransferPolicies(
 );
 
 // src/helpers/hasTransferPolicyRules.ts
-var hasNativeKioskTransferPolicyRules = (transferPolicies) => getNativeKioskTransferPolicies(transferPolicies)?.length > 0;
+var hasNativeKioskTransferPolicyRules = (transferPolicies) => {
+  const nativeKioskTransferPolicies = getNativeKioskTransferPolicies(transferPolicies);
+  return nativeKioskTransferPolicies?.some((policy) => policy?.rules?.length > 0);
+};
 
 // src/helpers/isSIngleBid.ts
 var isSingleBid = (bidType) => {
@@ -1561,211 +1564,16 @@ var kioskTxWrapper = async ({
   }
 };
 
-// src/helpers/originByte/confirmOBTranfer.ts
-var confirmOBTranfer = ({ tx, sharedObjects, transferRequest, nftType }) => {
-  tx.moveCall({
-    target: "0x6f42ec2355fcda5ebeee2399d901ae9f71cb214e640a45a0007f1f1cdf9f7b5e::transfer_allowlist::confirm_transfer",
-    arguments: [tx.object(sharedObjects?.allowList), tx.object(transferRequest)],
-    typeArguments: [nftType]
-  });
-  if (sharedObjects?.royaltyStrategy) {
-    tx.moveCall({
-      target: "0x6f42ec2355fcda5ebeee2399d901ae9f71cb214e640a45a0007f1f1cdf9f7b5e::royalty_strategy_bps::confirm_transfer",
-      arguments: [tx.object(sharedObjects?.royaltyStrategy), tx.object(transferRequest)],
-      typeArguments: [nftType, "0x2::sui::SUI"]
-    });
-  }
-  tx.moveCall({
-    target: "0xadf32ebafc587cc86e1e56e59f7b17c7e8cbeb3315193be63c6f73157d4e88b9::transfer_request::confirm",
-    arguments: [tx.object(transferRequest), tx.object(sharedObjects?.transferPolicy)],
-    typeArguments: [nftType, "0x2::sui::SUI"]
-  });
-};
-
-// src/helpers/originByte/depositNftIntoOBKiosk.ts
-var depositItemIntoOBKiosk = ({ tx, kiosk, nftTokenId, nftType }) => {
-  tx.moveCall({
-    target: "0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::deposit",
-    arguments: [tx.object(kiosk), tx.object(nftTokenId)],
-    typeArguments: [nftType]
-  });
-};
-
-// src/helpers/originByte/createOBKiosk.ts
-var createOBKiosk = async ({ tx, createMethod = "new" }) => {
-  const [kiosk] = tx.moveCall({
-    target: `0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::${createMethod}`,
-    arguments: [],
-    typeArguments: []
-  });
-  return [kiosk];
-};
-
-// src/graphql/queries/fetchWalletKiosks.ts
-var import_graphql_request10 = require("graphql-request");
-var fetchWalletKiosks = import_graphql_request10.gql`
-	query fetchWalletKiosks($wallet: String!) {
-		kiosks: kiosks_by_owner_address(owner_address: $wallet) {
-			id
-			is_origin_byte
-			is_personal
-			owner_address
-			profits
-			is_shared
-		}
-	}
-`;
-
-// src/helpers/originByte/getOBKiosk.ts
-var getOBKiosk = async (wallet) => {
-  const res = await gqlChainRequest({
-    chain: "sui",
-    query: fetchWalletKiosks,
-    variables: { wallet: addLeadingZerosAfter0x(wallet) }
-  });
-  return res?.kiosks?.filter((kiosk) => kiosk?.is_origin_byte && kiosk?.is_shared)?.[0]?.id;
-};
-
-// src/helpers/originByte/getOrCreateOBKiosk.ts
-var getOrCreateOBKiosk = async ({
-  tx,
-  address,
-  kioskToUseIfExists,
-  createMethod
-}) => {
-  if (kioskToUseIfExists) {
-    return {
-      kiosk: kioskToUseIfExists,
-      isNewKiosk: false
-    };
-  }
-  const existingKiosk = await getOBKiosk(address);
-  if (existingKiosk) {
-    return {
-      kiosk: existingKiosk,
-      isNewKiosk: false
-    };
-  }
-  const [newKiosk] = await createOBKiosk({ tx, createMethod });
-  return {
-    kiosk: newKiosk,
-    isNewKiosk: true
-  };
-};
-
-// src/helpers/originByte/isOriginByteBid.ts
-var isOriginByteBid = (bidType) => bidType === ORIGIN_BYTE_BID_NONCE_TYPE || bidType === "0x2::Kiosk::Kiosk" || bidType === "0x2::kiosk::Kiosk";
-
-// src/helpers/originByte/isOriginByteCollection.ts
-var isOriginByteCollection = (transferPolicies) => {
-  const hasOriginBytePolicies = transferPolicies?.filter((policy) => policy?.is_origin_byte)?.length > 0;
-  const hasNonOriginBytePoliciesWithRules = transferPolicies?.filter((policy) => !policy?.is_origin_byte)?.some((policy) => policy?.rules?.length > 0);
-  return Boolean(hasOriginBytePolicies && !hasNonOriginBytePoliciesWithRules);
-};
-
-// src/helpers/originByte/shareOriginByteKiosk.ts
-var shareOriginByteKiosk = async ({ tx, kiosk }) => {
-  tx.moveCall({
-    target: "0x2::transfer::public_share_object",
-    arguments: [tx.object(kiosk)],
-    typeArguments: ["0x2::kiosk::Kiosk"]
-  });
-};
-
-// src/helpers/rpc/getObjectType.ts
-var import_utils2 = require("@mysten/sui/utils");
-var getObjectType = async ({
-  suiClient,
-  objectId
-}) => {
-  const normalizedObjectId = objectId.startsWith("0x") ? addLeadingZerosAfter0x(objectId) : objectId;
-  if ((0, import_utils2.isValidSuiObjectId)(normalizedObjectId)) {
-    const res = await suiClient.getObject({ id: normalizedObjectId, options: { showType: true } });
-    return res.data.type;
-  }
-  return "";
-};
-
-// src/methods/acceptNftBids/addAcceptNftBidTxs.ts
-var import_utils3 = require("@mysten/sui/utils");
-
-// src/graphql/queries/fetchMultibidById.ts
-var import_graphql_request11 = require("graphql-request");
-var fetchMultibidChainIdById = import_graphql_request11.gql`
-	query fetchMultibidById($multiBidId: uuid!) {
-		multi_bids(where: { id: { _eq: $multiBidId } }) {
-			chain_id
-			cancelled_at
-		}
-	}
-`;
-
-// src/helpers/kiosk/lockNftInsideKioskIfNotLocked.ts
-var lockNftInsideKioskIfNotLocked = async ({
-  tx,
-  kioskClient,
+// src/helpers/kiosk/getKioskIdFromKioskTx.ts
+var getKioskIdFromKioskTx = ({
   kioskTx,
-  nftTokenId,
-  nftType,
-  transferPolicyId
+  tx
 }) => {
-  if (lockNftInsideKioskIfKioskCreatedInThisTx({ tx, kioskTx, nftTokenId, nftType, transferPolicyId })) {
-    return;
-  }
   const kioskId = "value" in kioskTx.kiosk ? kioskTx.kiosk.value : "Input" in kioskTx.kiosk ? tx.blockData.inputs[kioskTx.kiosk.Input].value : (() => {
     throw new Error("Invalid kiosk transaction structure");
   })();
-  const res = await kioskClient.getKiosk({ id: kioskId });
-  const nftInKiosk = res.items.find((i) => i.objectId === nftTokenId);
-  let takeFromKiosk = true;
-  if (!nftInKiosk) {
-    const result = await kioskClient.client.getObject({
-      id: nftTokenId,
-      options: { showOwner: true }
-    });
-    if (result.data.owner.AddressOwner) {
-      takeFromKiosk = false;
-    } else {
-      throw new Error(`NFT ${nftTokenId} is not found in kiosk ${kioskId}`);
-    }
-  }
-  if (!nftInKiosk?.isLocked) {
-    let takenNftId;
-    if (takeFromKiosk) {
-      const takenNft = kioskTx.take({
-        itemId: nftTokenId,
-        itemType: nftType
-      });
-      takenNftId = "value" in takenNft ? takenNft.value : takenNft;
-    }
-    kioskTx.lock({
-      itemId: takenNftId ?? nftTokenId,
-      itemType: nftType,
-      policy: transferPolicyId
-    });
-  }
+  return kioskId;
 };
-function lockNftInsideKioskIfKioskCreatedInThisTx({
-  tx,
-  kioskTx,
-  nftTokenId,
-  nftType,
-  transferPolicyId
-}) {
-  if (Array.isArray(kioskTx.kiosk.NestedResult)) {
-    const transaction = tx.blockData.transactions[kioskTx.kiosk.NestedResult[0]];
-    if (transaction.target === "0x0000000000000000000000000000000000000000000000000000000000000002::kiosk::new" || transaction.target === "0x0000000000000000000000000000000000000000000000000000000000000002::personal_kiosk::new") {
-      kioskTx.lock({
-        itemId: nftTokenId,
-        itemType: nftType,
-        policy: transferPolicyId
-      });
-      return true;
-    }
-    throw new Error(`Unsupported kiosk move call ${transaction.target}`);
-  }
-  return false;
-}
 
 // src/helpers/kiosk/resolveTransferPolicies.ts
 var import_kiosk4 = require("@mysten/kiosk");
@@ -2069,6 +1877,302 @@ var resolveTransferPolicies = async ({
   }
 };
 
+// src/helpers/kiosk/takeLockedNftFromKiosk.ts
+var takeLockedNftFromKiosk = async ({
+  tx,
+  transferPolicies,
+  suiClient,
+  kioskTx,
+  kioskClient,
+  nftTokenId,
+  nftType,
+  kioskOwner
+}) => {
+  const transferPolicy = getNativeKioskTransferPolicies(transferPolicies)?.at(0);
+  const hasFloorPriceRule = transferPolicy?.rules?.some(
+    (rule) => rule.type === "floor_price_rule"
+  );
+  if (hasFloorPriceRule) {
+    throw new Error("Cannot take locked NFT from kiosk with a minimum floor price rule");
+  }
+  const [purchase_cap] = tx.moveCall({
+    target: "0x2::kiosk::list_with_purchase_cap",
+    arguments: [
+      tx.object("value" in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk),
+      tx.object("value" in kioskTx.kioskCap ? kioskTx.kioskCap.value : kioskTx.kioskCap),
+      tx.pure.address(nftTokenId),
+      tx.pure.u64(0)
+    ],
+    typeArguments: [nftType]
+  });
+  const [zeroCoin] = tx.moveCall({
+    target: "0x2::coin::zero",
+    arguments: [],
+    typeArguments: ["0x2::sui::SUI"]
+  });
+  const [nft, transferRequest] = tx.moveCall({
+    target: "0x2::kiosk::purchase_with_cap",
+    arguments: [
+      tx.object("value" in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk),
+      purchase_cap,
+      zeroCoin
+    ],
+    typeArguments: [nftType]
+  });
+  await resolveTransferPolicies({
+    tx,
+    transferPolicies,
+    suiClient,
+    walletAddress: kioskOwner,
+    kioskTx,
+    kioskClient,
+    nftType,
+    price: "0",
+    transferRequest,
+    shouldSkipKioskLocking: true
+  });
+  return nft;
+};
+
+// src/helpers/kiosk/takeAndBorrowNftFromKiosk.ts
+var takeAndBorrowNftFromKiosk = async ({
+  tx,
+  transferPolicies,
+  kioskTx,
+  kioskClient,
+  nftTokenId,
+  nftType,
+  suiClient,
+  kioskOwner
+}) => {
+  const kioskId = getKioskIdFromKioskTx({ kioskTx, tx });
+  const res = await kioskClient.getKiosk({ id: kioskId });
+  const nftInKiosk = res.items.find((i) => i.objectId === nftTokenId);
+  let borrowedNft = null;
+  if (nftInKiosk?.isLocked) {
+    borrowedNft = await takeLockedNftFromKiosk({
+      tx,
+      transferPolicies,
+      kioskTx,
+      nftTokenId,
+      nftType,
+      suiClient,
+      kioskClient,
+      kioskOwner
+    });
+  } else {
+    borrowedNft = kioskTx.take({
+      itemId: nftTokenId,
+      itemType: nftType
+    });
+  }
+  return borrowedNft;
+};
+
+// src/helpers/originByte/confirmOBTranfer.ts
+var confirmOBTranfer = ({ tx, sharedObjects, transferRequest, nftType }) => {
+  tx.moveCall({
+    target: "0x6f42ec2355fcda5ebeee2399d901ae9f71cb214e640a45a0007f1f1cdf9f7b5e::transfer_allowlist::confirm_transfer",
+    arguments: [tx.object(sharedObjects?.allowList), tx.object(transferRequest)],
+    typeArguments: [nftType]
+  });
+  if (sharedObjects?.royaltyStrategy) {
+    tx.moveCall({
+      target: "0x6f42ec2355fcda5ebeee2399d901ae9f71cb214e640a45a0007f1f1cdf9f7b5e::royalty_strategy_bps::confirm_transfer",
+      arguments: [tx.object(sharedObjects?.royaltyStrategy), tx.object(transferRequest)],
+      typeArguments: [nftType, "0x2::sui::SUI"]
+    });
+  }
+  tx.moveCall({
+    target: "0xadf32ebafc587cc86e1e56e59f7b17c7e8cbeb3315193be63c6f73157d4e88b9::transfer_request::confirm",
+    arguments: [tx.object(transferRequest), tx.object(sharedObjects?.transferPolicy)],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+};
+
+// src/helpers/originByte/depositNftIntoOBKiosk.ts
+var depositItemIntoOBKiosk = ({ tx, kiosk, nftTokenId, nftType }) => {
+  tx.moveCall({
+    target: "0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::deposit",
+    arguments: [tx.object(kiosk), tx.object(nftTokenId)],
+    typeArguments: [nftType]
+  });
+};
+
+// src/helpers/originByte/createOBKiosk.ts
+var createOBKiosk = async ({ tx, createMethod = "new" }) => {
+  const [kiosk] = tx.moveCall({
+    target: `0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::${createMethod}`,
+    arguments: [],
+    typeArguments: []
+  });
+  return [kiosk];
+};
+
+// src/graphql/queries/fetchWalletKiosks.ts
+var import_graphql_request10 = require("graphql-request");
+var fetchWalletKiosks = import_graphql_request10.gql`
+	query fetchWalletKiosks($wallet: String!) {
+		kiosks: kiosks_by_owner_address(owner_address: $wallet) {
+			id
+			is_origin_byte
+			is_personal
+			owner_address
+			profits
+			is_shared
+		}
+	}
+`;
+
+// src/helpers/originByte/getOBKiosk.ts
+var getOBKiosk = async (wallet) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchWalletKiosks,
+    variables: { wallet: addLeadingZerosAfter0x(wallet) }
+  });
+  return res?.kiosks?.filter((kiosk) => kiosk?.is_origin_byte && kiosk?.is_shared)?.[0]?.id;
+};
+
+// src/helpers/originByte/getOrCreateOBKiosk.ts
+var getOrCreateOBKiosk = async ({
+  tx,
+  address,
+  kioskToUseIfExists,
+  createMethod
+}) => {
+  if (kioskToUseIfExists) {
+    return {
+      kiosk: kioskToUseIfExists,
+      isNewKiosk: false
+    };
+  }
+  const existingKiosk = await getOBKiosk(address);
+  if (existingKiosk) {
+    return {
+      kiosk: existingKiosk,
+      isNewKiosk: false
+    };
+  }
+  const [newKiosk] = await createOBKiosk({ tx, createMethod });
+  return {
+    kiosk: newKiosk,
+    isNewKiosk: true
+  };
+};
+
+// src/helpers/originByte/isOriginByteBid.ts
+var isOriginByteBid = (bidType) => bidType === ORIGIN_BYTE_BID_NONCE_TYPE || bidType === "0x2::Kiosk::Kiosk" || bidType === "0x2::kiosk::Kiosk";
+
+// src/helpers/originByte/isOriginByteCollection.ts
+var isOriginByteCollection = (transferPolicies) => {
+  const hasOriginBytePolicies = transferPolicies?.filter((policy) => policy?.is_origin_byte)?.length > 0;
+  const hasNonOriginBytePoliciesWithRules = transferPolicies?.filter((policy) => !policy?.is_origin_byte)?.some((policy) => policy?.rules?.length > 0);
+  return Boolean(hasOriginBytePolicies && !hasNonOriginBytePoliciesWithRules);
+};
+
+// src/helpers/originByte/shareOriginByteKiosk.ts
+var shareOriginByteKiosk = async ({ tx, kiosk }) => {
+  tx.moveCall({
+    target: "0x2::transfer::public_share_object",
+    arguments: [tx.object(kiosk)],
+    typeArguments: ["0x2::kiosk::Kiosk"]
+  });
+};
+
+// src/helpers/rpc/getObjectType.ts
+var import_utils2 = require("@mysten/sui/utils");
+var getObjectType = async ({
+  suiClient,
+  objectId
+}) => {
+  const normalizedObjectId = objectId.startsWith("0x") ? addLeadingZerosAfter0x(objectId) : objectId;
+  if ((0, import_utils2.isValidSuiObjectId)(normalizedObjectId)) {
+    const res = await suiClient.getObject({ id: normalizedObjectId, options: { showType: true } });
+    return res.data.type;
+  }
+  return "";
+};
+
+// src/methods/acceptNftBids/addAcceptNftBidTxs.ts
+var import_utils3 = require("@mysten/sui/utils");
+
+// src/graphql/queries/fetchMultibidById.ts
+var import_graphql_request11 = require("graphql-request");
+var fetchMultibidChainIdById = import_graphql_request11.gql`
+	query fetchMultibidById($multiBidId: uuid!) {
+		multi_bids(where: { id: { _eq: $multiBidId } }) {
+			chain_id
+			cancelled_at
+		}
+	}
+`;
+
+// src/helpers/kiosk/lockNftInsideKioskIfNotLocked.ts
+var lockNftInsideKioskIfNotLocked = async ({
+  tx,
+  kioskClient,
+  kioskTx,
+  nftTokenId,
+  nftType,
+  transferPolicyId
+}) => {
+  if (lockNftInsideKioskIfKioskCreatedInThisTx({ tx, kioskTx, nftTokenId, nftType, transferPolicyId })) {
+    return;
+  }
+  const kioskId = getKioskIdFromKioskTx({ kioskTx, tx });
+  const res = await kioskClient.getKiosk({ id: kioskId });
+  const nftInKiosk = res.items.find((i) => i.objectId === nftTokenId);
+  let takeFromKiosk = true;
+  if (!nftInKiosk) {
+    const result = await kioskClient.client.getObject({
+      id: nftTokenId,
+      options: { showOwner: true }
+    });
+    if (result.data.owner.AddressOwner) {
+      takeFromKiosk = false;
+    } else {
+      throw new Error(`NFT ${nftTokenId} is not found in kiosk ${kioskId}`);
+    }
+  }
+  if (!nftInKiosk?.isLocked) {
+    let takenNftId;
+    if (takeFromKiosk) {
+      const takenNft = kioskTx.take({
+        itemId: nftTokenId,
+        itemType: nftType
+      });
+      takenNftId = "value" in takenNft ? takenNft.value : takenNft;
+    }
+    kioskTx.lock({
+      itemId: takenNftId ?? nftTokenId,
+      itemType: nftType,
+      policy: transferPolicyId
+    });
+  }
+};
+function lockNftInsideKioskIfKioskCreatedInThisTx({
+  tx,
+  kioskTx,
+  nftTokenId,
+  nftType,
+  transferPolicyId
+}) {
+  if (Array.isArray(kioskTx.kiosk.NestedResult)) {
+    const transaction = tx.blockData.transactions[kioskTx.kiosk.NestedResult[0]];
+    if (transaction.target === "0x0000000000000000000000000000000000000000000000000000000000000002::kiosk::new" || transaction.target === "0x0000000000000000000000000000000000000000000000000000000000000002::personal_kiosk::new") {
+      kioskTx.lock({
+        itemId: nftTokenId,
+        itemType: nftType,
+        policy: transferPolicyId
+      });
+      return true;
+    }
+    throw new Error(`Unsupported kiosk move call ${transaction.target}`);
+  }
+  return false;
+}
+
 // src/helpers/originByte/getOBBidderKiosk.ts
 var getOBBidderKiosk = async ({
   suiClient,
@@ -2553,6 +2657,22 @@ async function addTradePortUnlistTxHandler(txData) {
           ...txData,
           kioskTx
         });
+        if (!hasNativeKioskTransferPolicyRules(txData?.transferPolicies)) {
+          const borrowedItem = await takeAndBorrowNftFromKiosk({
+            tx: txData?.tx,
+            transferPolicies: txData?.transferPolicies,
+            kioskTx,
+            kioskClient: txData?.kioskClient,
+            nftTokenId: txData?.nftTokenId,
+            nftType: txData?.nftType,
+            suiClient: txData?.suiClient,
+            kioskOwner: txData?.seller
+          });
+          txData?.tx.transferObjects(
+            [txData?.tx.object(borrowedItem)],
+            txData?.tx.pure.address(addLeadingZerosAfter0x(txData?.seller))
+          );
+        }
       }
     });
   }
@@ -2818,11 +2938,17 @@ async function addTradePortAcceptCollectionBidTxHandler(txData) {
       kiosk: txData?.sellerKiosk,
       shouldAssertNftInSharedKiosk: true,
       async runCommands(kioskTx) {
-        const item = kioskTx.take({
-          itemId: txData?.nftTokenId,
-          itemType: txData?.nftType
+        const borrowedItem = await takeAndBorrowNftFromKiosk({
+          tx: txData?.tx,
+          transferPolicies: txData?.transferPolicies,
+          kioskTx,
+          kioskClient: txData?.kioskClient,
+          nftTokenId: txData?.nftTokenId,
+          nftType: txData?.nftType,
+          suiClient: txData?.suiClient,
+          kioskOwner: txData?.seller
         });
-        addTradeportAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: item });
+        addTradeportAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: borrowedItem });
       }
     });
   }
@@ -2900,11 +3026,17 @@ async function addBluemoveAcceptCollectionBidTxHandler(txData) {
         kiosk: txData?.sellerKiosk,
         shouldAssertNftInSharedKiosk: true,
         async runCommands(kioskTx) {
-          const item = kioskTx.take({
-            itemId: txData?.nftTokenId,
-            itemType: txData?.nftType
+          const borrowedItem = await takeAndBorrowNftFromKiosk({
+            tx: txData?.tx,
+            transferPolicies: txData?.transferPolicies,
+            kioskTx,
+            kioskClient: txData?.kioskClient,
+            nftTokenId: txData?.nftTokenId,
+            nftType: txData?.nftType,
+            suiClient: txData?.suiClient,
+            kioskOwner: txData?.itemOwner
           });
-          addBluemoveAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: item });
+          addBluemoveAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: borrowedItem });
         }
       });
     }
@@ -5153,9 +5285,15 @@ async function addTradePortListTxHandler(txData) {
       kiosk: txData?.sellerKiosk,
       shouldAssertNftInSharedKiosk: true,
       async runCommands(kioskTx) {
-        const borrowedItem = kioskTx.take({
-          itemId: txData?.nftTokenId,
-          itemType: txData?.nftType
+        const borrowedItem = await takeAndBorrowNftFromKiosk({
+          tx: txData?.tx,
+          transferPolicies: txData?.transferPolicies,
+          kioskTx,
+          kioskClient: txData?.kioskClient,
+          nftTokenId: txData?.nftTokenId,
+          nftType: txData?.nftType,
+          suiClient: txData?.suiClient,
+          kioskOwner: txData?.seller
         });
         addTradePortListTx({ ...txData, borrowedItem });
       }
@@ -5176,7 +5314,7 @@ async function addTradePortListTxHandler(txData) {
       }
     });
   }
-  if (!txData?.sellerKiosk && getNativeKioskTransferPolicies(txData?.transferPolicies)) {
+  if (!txData?.sellerKiosk && hasNativeKioskTransferPolicyRules(txData?.transferPolicies)) {
     return kioskTxWrapper({
       tx: txData?.tx,
       kioskClient: txData?.kioskClient,
@@ -5219,22 +5357,22 @@ function addTradePortRelistTx({
   });
 }
 function addBlueMoveRelistTx(txData) {
-  const { tx, nftTokenId, nftType, listPrice } = txData;
+  const { tx, nftTokenId, nftType, listPrice, suiClient } = 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 });
+  addTradePortListTx({ ...txData, listPrice, borrowedItem, suiClient });
 }
 function addTocenRelistTx(txData) {
-  const { tx, nftTokenId, nftType, listPrice } = txData;
+  const { tx, nftTokenId, nftType, listPrice, suiClient } = 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 });
+  addTradePortListTx({ ...txData, listPrice, borrowedItem, suiClient });
 }
 
 // src/methods/relistNft/relistNft.ts
@@ -5365,6 +5503,7 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
     } else {
       const listTxData = {
         tx,
+        suiClient: context.suiClient,
         kioskClient: context.kioskClient,
         transferPolicies,
         seller: walletAddress,
@@ -5710,6 +5849,7 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
             tx,
             kioskTx,
             kioskClient: context?.kioskClient,
+            suiClient: context?.suiClient,
             senderKiosk: unsharedNativeKiosk,
             senderAddress: walletAddress,
             recipientAddress: walletAddress,
@@ -6414,6 +6554,7 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
     const transferPolicies = nft?.collection?.chain_state?.transfer_policies;
     const txData = {
       tx,
+      suiClient: context.suiClient,
       kioskClient: context.kioskClient,
       nftType,
       nftTokenId: nft?.token_id,
@@ -6422,6 +6563,32 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
       recipientAddress,
       transferPolicies
     };
+    if (txData?.senderKiosk && !hasNativeKioskTransferPolicyRules(txData?.transferPolicies)) {
+      await kioskTxWrapper({
+        tx: txData?.tx,
+        kioskClient: txData?.kioskClient,
+        kioskOwner: txData?.senderAddress,
+        kiosk: txData?.senderKiosk,
+        shouldAssertNftInSharedKiosk: true,
+        async runCommands(kioskTx) {
+          const borrowedItem = await takeAndBorrowNftFromKiosk({
+            tx: txData?.tx,
+            transferPolicies: txData?.transferPolicies,
+            kioskTx,
+            kioskClient: txData?.kioskClient,
+            nftTokenId: txData?.nftTokenId,
+            nftType: txData?.nftType,
+            suiClient: txData?.suiClient,
+            kioskOwner: txData?.senderAddress
+          });
+          tx.transferObjects(
+            [tx.object(borrowedItem)],
+            tx.pure.address(addLeadingZerosAfter0x(recipientAddress))
+          );
+        }
+      });
+      continue;
+    }
     if (!txData.senderKiosk) {
       tx.transferObjects(
         [tx.object(txData.nftTokenId)],