@tradeport/sui-trading-sdk 0.4.14 → 0.4.16

package/dist/index.js

@@ -1280,7 +1280,7 @@ var getSharedObjects = async (nftType) => {
 };
 
 // src/methods/acceptCollectionBid/addAcceptCollectionBIdTxs.ts
-var import_utils3 = require("@mysten/sui/utils");
+var import_utils4 = require("@mysten/sui/utils");
 
 // src/utils/normalizeNftType.ts
 var normalizedNftType = (nftType) => {
@@ -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) => {
@@ -1379,16 +1382,52 @@ function addHexPrefix(input) {
   return "0x" + input;
 }
 
+// src/helpers/getTransferPolicyRuleNamesFromSuiObject.ts
+var import_utils = require("@mysten/sui/utils");
+var getTransferPolicyRuleNamesFromSuiObject = async ({
+  suiClient,
+  transferPolicyId
+}) => {
+  const { data, error } = await suiClient.getObject({
+    id: (0, import_utils.normalizeSuiObjectId)(transferPolicyId),
+    options: {
+      showContent: true
+    }
+  });
+  if (error) {
+    throw new Error(`Error on getting SUI object ${transferPolicyId}: ${error.code}`);
+  }
+  const content = data.content;
+  const ruleNames = content.fields.rules.fields.contents.map(
+    (rule) => (0, import_utils.normalizeStructTag)(rule.fields.name)
+  );
+  return ruleNames;
+};
+
 // src/helpers/kiosk/getRulePackageId.ts
 var getRulePackageId = async ({
+  transferPolicies,
   nftType,
   ruleType,
-  kioskClient
+  kioskClient,
+  suiClient
 }) => {
-  const transferPolicies = await kioskClient.getTransferPolicies({
+  const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
     type: normalizedNftType(nftType)
   });
-  const rule = transferPolicies.flatMap((policy) => policy.rules).filter((rule2) => rule2?.split("::")?.[1] === ruleType)?.[0];
+  let rule;
+  if (transferPoliciesFromMystenSdk.length > 0) {
+    rule = transferPoliciesFromMystenSdk.flatMap((policy) => policy.rules).filter((rule2) => rule2?.split("::")?.[1] === ruleType)?.[0];
+  } else if (transferPolicies.length > 0) {
+    const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+    const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
+      suiClient,
+      transferPolicyId
+    });
+    rule = ruleNames.filter((ruleName) => ruleName?.split("::")?.[1] === ruleType)?.[0];
+  } else {
+    throw new Error(`No transfer policy found for ${nftType}`);
+  }
   const ruleDefinition = kioskClient.rules.find(
     (x) => (0, import_kiosk2.getNormalizedRuleType)(x.rule) === (0, import_kiosk2.getNormalizedRuleType)(rule)
   );
@@ -1525,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_utils = require("@mysten/sui/utils");
-var getObjectType = async ({
-  suiClient,
-  objectId
-}) => {
-  const normalizedObjectId = objectId.startsWith("0x") ? addLeadingZerosAfter0x(objectId) : objectId;
-  if ((0, import_utils.isValidSuiObjectId)(normalizedObjectId)) {
-    const res = await suiClient.getObject({ id: normalizedObjectId, options: { showType: true } });
-    return res.data.type;
-  }
-  return "";
-};
-
-// src/methods/acceptNftBids/addAcceptNftBidTxs.ts
-var import_utils2 = 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");
@@ -1860,161 +1704,474 @@ async function resolveRoyaltyRule({
   });
 }
 
-// src/helpers/kiosk/resolveTransferPolicies.ts
-var originByteRuleModules = ["royalty_strategy_bps", "transfer_allowlist"];
-var resolveTransferPolicies = async ({
+// src/helpers/kiosk/resolveTransferPolicies.ts
+var originByteRuleModules = ["royalty_strategy_bps", "transfer_allowlist"];
+var resolveTransferPolicies = async ({
+  tx,
+  transferPolicies,
+  suiClient,
+  walletAddress,
+  kioskClient,
+  kioskTx,
+  nftType,
+  kioskToLockRuleProve,
+  kioskItem,
+  transferRequest,
+  customTransferPolicies,
+  price,
+  shouldSkipKioskLocking,
+  shouldSkipResolvingRoyaltyRule,
+  coinToSplit,
+  beforeResolveKioskTransferRequest
+}) => {
+  const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
+    type: normalizedNftType(nftType)
+  });
+  let policies = [];
+  if (transferPoliciesFromMystenSdk.length > 0) {
+    policies = [
+      {
+        data: (
+          // Find first policy with relevant rules, or fall back to first policy
+          transferPoliciesFromMystenSdk.find(
+            (policy) => policy?.rules?.some(
+              (rule) => knownTransferPolicyRules.some((ruleType) => rule?.includes(ruleType))
+            )
+          ) ?? transferPoliciesFromMystenSdk[0]
+        ),
+        transferRequest,
+        isCustom: false
+      }
+    ];
+  } else if (transferPolicies.length > 0) {
+    const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+    if (transferPolicyId) {
+      const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
+        suiClient,
+        transferPolicyId
+      });
+      if (ruleNames.length > 0) {
+        policies = [
+          {
+            data: {
+              id: transferPolicyId,
+              rules: ruleNames
+            },
+            transferRequest,
+            isCustom: false
+          }
+        ];
+      }
+    }
+  } else if ((customTransferPolicies ?? []).every(
+    (p) => p.transferRequest !== transferRequest
+  )) {
+    throw new Error(
+      `Missing transfer policy of ${nftType}. No way to resolve the transfer request.`
+    );
+  }
+  if (customTransferPolicies) {
+    for (const customTransferPolicy of customTransferPolicies) {
+      const customPolicy = await kioskClient.getTransferPolicies({
+        type: normalizedNftType(customTransferPolicy?.type)
+      });
+      policies = [
+        ...policies,
+        {
+          data: customPolicy[0],
+          transferRequest: customTransferPolicy?.transferRequest,
+          isCustom: true,
+          type: customTransferPolicy?.type
+        }
+      ];
+    }
+  }
+  let canTransferOutsideKiosk = true;
+  for (const policy of policies) {
+    const kioskLockRule = policy?.data?.rules.find(
+      (rule) => rule?.includes("kiosk_lock_rule")
+    );
+    const personalKioskRule = policy.data.rules.find(
+      (rule) => rule.includes("personal_kiosk_rule")
+    );
+    const otherRules = policy.data.rules.filter(
+      (rule) => !rule?.includes("kiosk_lock_rule") && !rule?.includes("personal_kiosk_rule")
+    );
+    const sortedRules = [kioskLockRule, personalKioskRule, ...otherRules].filter(Boolean);
+    for (const rule of sortedRules) {
+      const ruleDefinition = kioskClient.rules.find(
+        (x) => (0, import_kiosk4.getNormalizedRuleType)(x.rule) === (0, import_kiosk4.getNormalizedRuleType)(rule)
+      );
+      let rulePackageId = ruleDefinition?.packageId;
+      if (!rulePackageId) {
+        rulePackageId = rule?.split("::")?.[0];
+      }
+      const moduleName = rule?.split("::")?.[1];
+      if (originByteRuleModules.includes(moduleName)) {
+        throw new Error(`Using Origin Byte rule ${rule} inside the native kiosk transaction`);
+      }
+      switch (moduleName) {
+        case "kiosk_lock_rule":
+          canTransferOutsideKiosk = false;
+          resolveKioskLockRule({
+            tx,
+            packageId: rulePackageId,
+            policyId: policy.data.id,
+            transferRequest: policy.transferRequest,
+            nftType: policy.isCustom && policy.type ? policy.type : nftType,
+            kiosk: kioskToLockRuleProve ? kioskToLockRuleProve : kioskTx.kiosk,
+            kioskCap: kioskTx.kioskCap,
+            kioskItem,
+            shouldSkipLocking: shouldSkipKioskLocking
+          });
+          break;
+        case "personal_kiosk_rule":
+          resolvePersonalKioskRule({
+            tx,
+            packageId: rulePackageId,
+            nftType: policy.isCustom && policy.type ? policy.type : nftType,
+            kiosk: kioskTx.kiosk,
+            transferRequest: policy.transferRequest
+          });
+          break;
+        case "royalty_rule":
+        case "kiosk_royalty_rule":
+          if (shouldSkipResolvingRoyaltyRule) break;
+          await resolveRoyaltyRule({
+            tx,
+            suiClient,
+            walletAddress,
+            packageId: rulePackageId,
+            moduleName,
+            policyId: policy.data.id,
+            transferRequest: policy.transferRequest,
+            nftType: policy.isCustom && policy.type ? policy.type : nftType,
+            price,
+            coinToSplit
+          });
+          break;
+        case "floor_price_rule":
+          resolveFloorPriceRule({
+            tx,
+            packageId: rulePackageId,
+            nftType: policy.isCustom && policy.type ? policy.type : nftType,
+            policyId: policy.data.id,
+            transferRequest: policy.transferRequest
+          });
+          break;
+        default:
+          throw new Error(`No resolver for the following rule: ${rule}.`);
+      }
+    }
+  }
+  if (canTransferOutsideKiosk && kioskItem) {
+    kioskTx.place({ itemType: nftType, item: kioskItem });
+  }
+  await beforeResolveKioskTransferRequest?.(transferRequest);
+  for (const policy of policies) {
+    tx.moveCall({
+      target: "0x2::transfer_policy::confirm_request",
+      arguments: [tx.object(policy.data.id), policy.transferRequest],
+      typeArguments: [policy.isCustom && policy.type ? policy.type : nftType]
+    });
+  }
+};
+
+// 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,
-  suiClient,
-  walletAddress,
   kioskClient,
   kioskTx,
+  nftTokenId,
   nftType,
-  kioskToLockRuleProve,
-  kioskItem,
-  transferRequest,
-  customTransferPolicies,
-  price,
-  shouldSkipKioskLocking,
-  shouldSkipResolvingRoyaltyRule,
-  coinToSplit,
-  beforeResolveKioskTransferRequest
+  transferPolicyId
 }) => {
-  const transferPolicies = await kioskClient.getTransferPolicies({
-    type: normalizedNftType(nftType)
-  });
-  if (transferPolicies.length === 0 && (customTransferPolicies ?? []).every(
-    (p) => p.transferRequest !== transferRequest
-  )) {
-    throw new Error(
-      `Missing transfer policy of ${nftType}. No way to resolve the transfer request.`
-    );
+  if (lockNftInsideKioskIfKioskCreatedInThisTx({ tx, kioskTx, nftTokenId, nftType, transferPolicyId })) {
+    return;
   }
-  let policies = transferPolicies.length > 0 ? [
-    {
-      data: transferPolicies?.filter(
-        (policy) => policy?.rules?.filter(
-          (rule) => rule?.includes("royalty_rule") || rule?.includes("kiosk_lock_rule") || rule?.includes("personal_kiosk_rule") || rule?.includes("floor_price_rule")
-        )?.length > 0
-      )?.[0],
-      transferRequest,
-      isCustom: false
+  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 (!policies?.[0]?.data && transferPolicies.length > 0) {
-    policies = [
-      {
-        data: transferPolicies?.[0],
-        transferRequest,
-        isCustom: false
-      }
-    ];
   }
-  if (customTransferPolicies) {
-    for (const customTransferPolicy of customTransferPolicies) {
-      const customPolicy = await kioskClient.getTransferPolicies({
-        type: normalizedNftType(customTransferPolicy?.type)
+  if (!nftInKiosk?.isLocked) {
+    let takenNftId;
+    if (takeFromKiosk) {
+      const takenNft = kioskTx.take({
+        itemId: nftTokenId,
+        itemType: nftType
       });
-      policies = [
-        ...policies,
-        {
-          data: customPolicy[0],
-          transferRequest: customTransferPolicy?.transferRequest,
-          isCustom: true,
-          type: customTransferPolicy?.type
-        }
-      ];
-    }
-  }
-  let canTransferOutsideKiosk = true;
-  for (const policy of policies) {
-    const kioskLockRule = policy?.data?.rules.find(
-      (rule) => rule?.includes("kiosk_lock_rule")
-    );
-    const personalKioskRule = policy.data.rules.find(
-      (rule) => rule.includes("personal_kiosk_rule")
-    );
-    const otherRules = policy.data.rules.filter(
-      (rule) => !rule?.includes("kiosk_lock_rule") && !rule?.includes("personal_kiosk_rule")
-    );
-    const sortedRules = [kioskLockRule, personalKioskRule, ...otherRules].filter(Boolean);
-    for (const rule of sortedRules) {
-      const ruleDefinition = kioskClient.rules.find(
-        (x) => (0, import_kiosk4.getNormalizedRuleType)(x.rule) === (0, import_kiosk4.getNormalizedRuleType)(rule)
-      );
-      let rulePackageId = ruleDefinition?.packageId;
-      if (!rulePackageId) {
-        rulePackageId = rule?.split("::")?.[0];
-      }
-      const moduleName = rule?.split("::")?.[1];
-      if (originByteRuleModules.includes(moduleName)) {
-        throw new Error(`Using Origin Byte rule ${rule} inside the native kiosk transaction`);
-      }
-      switch (moduleName) {
-        case "kiosk_lock_rule":
-          canTransferOutsideKiosk = false;
-          resolveKioskLockRule({
-            tx,
-            packageId: rulePackageId,
-            policyId: policy.data.id,
-            transferRequest: policy.transferRequest,
-            nftType: policy.isCustom && policy.type ? policy.type : nftType,
-            kiosk: kioskToLockRuleProve ? kioskToLockRuleProve : kioskTx.kiosk,
-            kioskCap: kioskTx.kioskCap,
-            kioskItem,
-            shouldSkipLocking: shouldSkipKioskLocking
-          });
-          break;
-        case "personal_kiosk_rule":
-          resolvePersonalKioskRule({
-            tx,
-            packageId: rulePackageId,
-            nftType: policy.isCustom && policy.type ? policy.type : nftType,
-            kiosk: kioskTx.kiosk,
-            transferRequest: policy.transferRequest
-          });
-          break;
-        case "royalty_rule":
-        case "kiosk_royalty_rule":
-          if (shouldSkipResolvingRoyaltyRule) break;
-          await resolveRoyaltyRule({
-            tx,
-            suiClient,
-            walletAddress,
-            packageId: rulePackageId,
-            moduleName,
-            policyId: policy.data.id,
-            transferRequest: policy.transferRequest,
-            nftType: policy.isCustom && policy.type ? policy.type : nftType,
-            price,
-            coinToSplit
-          });
-          break;
-        case "floor_price_rule":
-          resolveFloorPriceRule({
-            tx,
-            packageId: rulePackageId,
-            nftType: policy.isCustom && policy.type ? policy.type : nftType,
-            policyId: policy.data.id,
-            transferRequest: policy.transferRequest
-          });
-          break;
-        default:
-          throw new Error(`No resolver for the following rule: ${rule}.`);
-      }
+      takenNftId = "value" in takenNft ? takenNft.value : takenNft;
     }
-  }
-  if (canTransferOutsideKiosk && kioskItem) {
-    kioskTx.place({ itemType: nftType, item: kioskItem });
-  }
-  await beforeResolveKioskTransferRequest?.(transferRequest);
-  for (const policy of policies) {
-    tx.moveCall({
-      target: "0x2::transfer_policy::confirm_request",
-      arguments: [tx.object(policy.data.id), policy.transferRequest],
-      typeArguments: [policy.isCustom && policy.type ? policy.type : nftType]
+    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 ({
@@ -2101,6 +2258,7 @@ async function addTradeportKioskAcceptNftBidTx({
     await beforeResolveKioskTransferRequest?.(feeCoin, transferRequest);
     await resolveTransferPolicies({
       tx,
+      transferPolicies,
       suiClient,
       walletAddress: seller,
       kioskTx,
@@ -2133,6 +2291,7 @@ async function addTradeportKioskAcceptNftBidTx({
     }
     await resolveTransferPolicies({
       tx,
+      transferPolicies,
       suiClient,
       walletAddress: seller,
       kioskTx,
@@ -2215,7 +2374,7 @@ function addBluemoveAcceptNftBidTx({
   });
 }
 async function addSingleBidAcceptNftBidTx(txData) {
-  const { nftType, tx, bidNonce, multiBidId, kioskClient, nftTokenId } = txData;
+  const { nftType, tx, bidNonce, multiBidId, kioskClient, nftTokenId, suiClient } = txData;
   const transferPolicies = getNativeKioskTransferPolicies(txData?.transferPolicies);
   const transferPolicy = transferPolicies?.find(
     (policy) => policy?.rules?.length > 0
@@ -2230,9 +2389,15 @@ async function addSingleBidAcceptNftBidTx(txData) {
   }
   if (transferPolicy) {
     const transferPolicies2 = await kioskClient.getTransferPolicies({
-      type: (0, import_utils2.normalizeStructTag)(nftType)
+      type: (0, import_utils3.normalizeStructTag)(nftType)
     });
-    const { rules: allRules } = transferPolicies2.find((p) => p.id === transferPolicy.id);
+    let { rules: allRules } = transferPolicies2.find((p) => p.id === transferPolicy.id);
+    if (allRules.length === 0) {
+      allRules = await getTransferPolicyRuleNamesFromSuiObject({
+        suiClient,
+        transferPolicyId: transferPolicy.id
+      });
+    }
     const unsupportedRule = allRules.find(
       (r) => !knownTransferPolicyRules.includes(r.split("::").at(1))
     );
@@ -2252,9 +2417,9 @@ async function addSingleBidAcceptNftBidTx(txData) {
           target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::accept_bid_with_transfer_policy`,
           typeArguments: [nftType],
           arguments: [
-            tx.object(import_utils2.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils3.SUI_CLOCK_OBJECT_ID),
             tx.object(TRADEPORT_MULTI_BID_STORE),
-            tx.pure.id((0, import_utils2.normalizeSuiObjectId)(bidNonce)),
+            tx.pure.id((0, import_utils3.normalizeSuiObjectId)(bidNonce)),
             tx.pure.option("id", multiBidChainId),
             tx.object(kioskTx.getKiosk()),
             tx.object(kioskTx.getKioskCap()),
@@ -2274,7 +2439,7 @@ async function addSingleBidAcceptNftBidTx(txData) {
     target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::accept_bid_without_transfer_policy`,
     typeArguments: [nftType],
     arguments: [
-      tx.object(import_utils2.SUI_CLOCK_OBJECT_ID),
+      tx.object(import_utils3.SUI_CLOCK_OBJECT_ID),
       tx.object(TRADEPORT_MULTI_BID_STORE),
       tx.pure.id(bidNonce),
       tx.pure.option("id", multiBidChainId),
@@ -2285,7 +2450,7 @@ async function addSingleBidAcceptNftBidTx(txData) {
 async function addTradePortAcceptNftBidTxHandler(txData) {
   const bidType = await getObjectType({
     suiClient: txData?.suiClient,
-    objectId: (0, import_utils2.normalizeSuiObjectId)(txData?.bidNonce)
+    objectId: (0, import_utils3.normalizeSuiObjectId)(txData?.bidNonce)
   });
   if (isSingleBid(bidType)) {
     await addSingleBidAcceptNftBidTx(txData);
@@ -2305,6 +2470,8 @@ async function addTradePortAcceptNftBidTxHandler(txData) {
     if (txData?.sellerKiosk) {
       const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
       const royaltyRulePackageId = await getRulePackageId({
+        transferPolicies: txData?.transferPolicies,
+        suiClient: txData?.suiClient,
         nftType: txData?.nftType,
         ruleType: "royalty_rule",
         kioskClient: txData?.kioskClient
@@ -2490,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))
+          );
+        }
       }
     });
   }
@@ -2730,7 +2913,7 @@ function addTocenAcceptCollectionBidTx({
 async function addTradePortAcceptCollectionBidTxHandler(txData) {
   const bidType = await getObjectType({
     suiClient: txData?.suiClient,
-    objectId: (0, import_utils3.normalizeSuiObjectId)(txData?.bidNonce)
+    objectId: (0, import_utils4.normalizeSuiObjectId)(txData?.bidNonce)
   });
   if (isSingleBid(bidType)) {
     await addSingleBidAcceptNftBidTx(txData);
@@ -2755,17 +2938,25 @@ 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 });
       }
     });
   }
   if (isTradePortKioskBid(bidType)) {
     const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
     const royaltyRulePackageId = await getRulePackageId({
+      transferPolicies: txData?.transferPolicies,
+      suiClient: txData?.suiClient,
       nftType: txData?.nftType,
       ruleType: "royalty_rule",
       kioskClient: txData?.kioskClient
@@ -2835,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 });
         }
       });
     }
@@ -3075,7 +3272,7 @@ var acceptNftBids = async ({
 var import_transactions6 = require("@mysten/sui/transactions");
 
 // src/methods/buyLocks/buyLocks.ts
-var import_utils4 = require("@mysten/sui.js/utils");
+var import_utils5 = require("@mysten/sui.js/utils");
 var import_transactions4 = require("@mysten/sui/transactions");
 
 // src/helpers/calculatePremium.ts
@@ -3241,7 +3438,7 @@ async function buyLocks({ lockIds, transaction }, context) {
       typeArguments: [lock.nft_type],
       arguments: [
         tx.object(TRADEPORT_PRICE_LOCK_STORE),
-        tx.object(import_utils4.SUI_CLOCK_OBJECT_ID),
+        tx.object(import_utils5.SUI_CLOCK_OBJECT_ID),
         tx.pure.id(lock.lock_id),
         tx.pure.u64(lock.maker_price),
         tx.pure.u64(marketplaceFee),
@@ -3255,7 +3452,7 @@ async function buyLocks({ lockIds, transaction }, context) {
 }
 
 // src/methods/exerciseLongLocks/exerciseLongLocks.ts
-var import_utils5 = require("@mysten/sui.js/utils");
+var import_utils6 = require("@mysten/sui.js/utils");
 var import_transactions5 = require("@mysten/sui/transactions");
 async function exerciseLongLocks({ walletAddress, transaction, locks }, context) {
   const tx = transaction ?? new import_transactions5.Transaction();
@@ -3313,7 +3510,7 @@ async function exerciseLongLocks({ walletAddress, transaction, locks }, context)
           typeArguments: [lock.nft_type],
           arguments: [
             tx.object(TRADEPORT_PRICE_LOCK_STORE),
-            tx.object(import_utils5.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils6.SUI_CLOCK_OBJECT_ID),
             tx.pure.id(lock.lock_id),
             tx.object(lock.chain_state.makerKioskId),
             tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
@@ -3323,6 +3520,7 @@ async function exerciseLongLocks({ walletAddress, transaction, locks }, context)
         });
         await resolveTransferPolicies({
           tx,
+          transferPolicies,
           suiClient: context.suiClient,
           walletAddress,
           kioskTx,
@@ -3390,6 +3588,7 @@ async function exerciseLongLocks({ walletAddress, transaction, locks }, context)
           });
           await resolveTransferPolicies({
             tx,
+            transferPolicies,
             suiClient: context.suiClient,
             walletAddress,
             kioskTx,
@@ -3418,7 +3617,7 @@ async function buyAndExerciseLongLocks({ walletAddress, locks, tx: existingTx },
 var import_transactions9 = require("@mysten/sui/transactions");
 
 // src/methods/exerciseShortLocks/exerciseShortLocks.ts
-var import_utils6 = require("@mysten/sui.js/utils");
+var import_utils7 = require("@mysten/sui.js/utils");
 var import_transactions8 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchListingsById.ts
@@ -3542,6 +3741,7 @@ function addTradePortBuyTx({ tx, nftType, listingNonce, price, sharedObjects })
 }
 var addTradeportKioskBuyTx = async ({
   tx,
+  transferPolicies,
   kioskTx,
   suiClient,
   kioskClient,
@@ -3578,6 +3778,7 @@ var addTradeportKioskBuyTx = async ({
   });
   await resolveTransferPolicies({
     tx,
+    transferPolicies,
     suiClient,
     walletAddress: seller,
     kioskTx,
@@ -3630,6 +3831,7 @@ async function addOriginByteBuyTx({
 }
 var addHyperspaceKioskBuyTx = async ({
   tx,
+  transferPolicies,
   suiClient,
   kioskTx,
   kioskClient,
@@ -3661,6 +3863,7 @@ var addHyperspaceKioskBuyTx = async ({
   await beforeResolveKioskTransferRequest?.(transferRequest);
   await resolveTransferPolicies({
     tx,
+    transferPolicies,
     suiClient,
     walletAddress: seller,
     kioskTx,
@@ -3725,6 +3928,7 @@ async function addBluemoveKioskBuyTx({
   await beforeResolveKioskTransferRequest?.(transferRequest);
   await resolveTransferPolicies({
     tx,
+    transferPolicies,
     suiClient,
     walletAddress: seller,
     kioskTx,
@@ -4141,7 +4345,7 @@ async function exerciseShortLocks({ walletAddress, transaction, locks }, context
           typeArguments: [lock.nft_type],
           arguments: [
             tx.object(TRADEPORT_PRICE_LOCK_STORE),
-            tx.object(import_utils6.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils7.SUI_CLOCK_OBJECT_ID),
             tx.pure.id(lock.lock_id)
           ]
         });
@@ -4192,6 +4396,7 @@ async function exerciseShortLocks({ walletAddress, transaction, locks }, context
           });
           await resolveTransferPolicies({
             tx,
+            transferPolicies,
             suiClient: context.suiClient,
             walletAddress,
             kioskTx,
@@ -4222,7 +4427,7 @@ async function buyAndExerciseShortLocks({ walletAddress, locks, tx: existingTx }
 }
 
 // src/methods/cancelLocks/cancelLocks.ts
-var import_utils7 = require("@mysten/sui.js/utils");
+var import_utils8 = require("@mysten/sui.js/utils");
 var import_transactions10 = require("@mysten/sui/transactions");
 async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, context) {
   const tx = existingTx ?? new import_transactions10.Transaction();
@@ -4245,7 +4450,7 @@ async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, context)
           typeArguments: [lock.nft_type],
           arguments: [
             tx.object(TRADEPORT_PRICE_LOCK_STORE),
-            tx.object(import_utils7.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils8.SUI_CLOCK_OBJECT_ID),
             tx.pure.id(lock.lock_id),
             tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk)
           ]
@@ -4423,6 +4628,7 @@ var addClaimAcceptedBidNftTx = async ({
   });
   await resolveTransferPolicies({
     tx,
+    transferPolicies,
     suiClient,
     walletAddress: claimer,
     kioskTx,
@@ -4459,6 +4665,7 @@ var addClaimAcceptedBidNftWithPurchaseCapTx = async ({
   });
   await resolveTransferPolicies({
     tx,
+    transferPolicies,
     suiClient,
     walletAddress: claimer,
     kioskTx,
@@ -4494,6 +4701,7 @@ var addClaimTransferredNftTx = async ({
   });
   await resolveTransferPolicies({
     tx,
+    transferPolicies,
     suiClient,
     walletAddress: claimer,
     kioskTx,
@@ -4531,6 +4739,7 @@ var addClaimTransferredNftWithPurchaseCapTx = async ({
   });
   await resolveTransferPolicies({
     tx,
+    transferPolicies,
     suiClient,
     walletAddress: claimer,
     kioskTx,
@@ -5076,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 });
       }
@@ -5099,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,
@@ -5142,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
@@ -5288,6 +5503,7 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
     } else {
       const listTxData = {
         tx,
+        suiClient: context.suiClient,
         kioskClient: context.kioskClient,
         transferPolicies,
         seller: walletAddress,
@@ -5360,7 +5576,6 @@ var fetchBulkNftsByKioskId = import_graphql_request19.gql`
 `;
 
 // src/methods/transferNfts/addTransferNftTx.ts
-var import_utils8 = require("@mysten/sui/utils");
 async function addOriginByteTransferNftTx({
   tx,
   nftTokenId,
@@ -5499,19 +5714,10 @@ async function getTransferPolicyForDirectTransfer(suiClient, collectionChainStat
     ).length === 0
   );
   if (validateRules && candidatePolicy) {
-    const { data, error } = await suiClient.getObject({
-      id: (0, import_utils8.normalizeSuiObjectId)(candidatePolicy.id),
-      options: {
-        showContent: true
-      }
+    const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
+      suiClient,
+      transferPolicyId: candidatePolicy.id
     });
-    if (error) {
-      throw new Error(`Error on getting SUI object ${candidatePolicy.id}: ${error.code}`);
-    }
-    const content = data.content;
-    const ruleNames = content.fields.rules.fields.contents.map(
-      (rule) => (0, import_utils8.normalizeStructTag)(rule.fields.name)
-    );
     if (!ruleNames.every((name) => name.startsWith(MYSTEN_TRANFER_POLICY_RULES_PACKAGE_ID))) {
       return void 0;
     }
@@ -5643,6 +5849,7 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
             tx,
             kioskTx,
             kioskClient: context?.kioskClient,
+            suiClient: context?.suiClient,
             senderKiosk: unsharedNativeKiosk,
             senderAddress: walletAddress,
             recipientAddress: walletAddress,
@@ -6347,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,
@@ -6355,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)],