@tradeport/sui-trading-sdk 0.4.24 → 0.4.26

package/dist/index.js

@@ -1355,18 +1355,17 @@ var fetchKiosksByOwner = import_graphql_request7.gql`
 var assertNftInSharedKiosk = async ({
   kioskId,
   walletAddress,
-  kiosks
+  sharedKioskState
 }) => {
-  let kiosksToCheck = kiosks;
-  if (!kiosksToCheck) {
+  if (!sharedKioskState?.ownerKiosks) {
     const res = await gqlChainRequest({
       chain: "sui",
       query: fetchKiosksByOwner,
       variables: { ownerAddress: addLeadingZerosAfter0x(walletAddress) }
     });
-    kiosksToCheck = res?.kiosks;
+    sharedKioskState.ownerKiosks = res?.kiosks;
   }
-  const nftKiosk = kiosksToCheck?.find((k) => k.id === kioskId);
+  const nftKiosk = sharedKioskState?.ownerKiosks?.find((k) => k.id === kioskId);
   if (nftKiosk && !nftKiosk?.is_shared) {
     throw new Error("NFT is inside a kiosk that is not shared");
   }
@@ -1413,13 +1412,8 @@ var getRulePackageId = async ({
   kioskClient,
   suiClient
 }) => {
-  const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
-    type: normalizedNftType(nftType)
-  });
   let rule;
-  if (transferPoliciesFromMystenSdk.length > 0) {
-    rule = transferPoliciesFromMystenSdk.flatMap((policy) => policy.rules).filter((rule2) => rule2?.split("::")?.[1] === ruleType)?.[0];
-  } else if (transferPolicies.length > 0) {
+  if (transferPolicies.length > 0) {
     const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
     const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
       suiClient,
@@ -1427,7 +1421,14 @@ var getRulePackageId = async ({
     });
     rule = ruleNames.filter((ruleName) => ruleName?.split("::")?.[1] === ruleType)?.[0];
   } else {
-    throw new Error(`No transfer policy found for ${nftType}`);
+    const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
+      type: normalizedNftType(nftType)
+    });
+    if (transferPoliciesFromMystenSdk.length > 0) {
+      rule = transferPoliciesFromMystenSdk.flatMap((policy) => policy.rules).filter((rule2) => rule2?.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)
@@ -1474,32 +1475,34 @@ var fetchPersonalCapByKiosk = import_graphql_request9.gql`
 var kioskTxWrapper = async ({
   tx,
   kioskClient,
-  kioskTx,
   kioskOwner,
   kiosk,
-  kioskOwnerKiosks,
   runCommands,
   shouldConvertToPersonalKiosk,
   shouldAssertNftInSharedKiosk,
   shouldAllowNftUnsharedKiosk,
-  shouldSkipFinalize,
   kioskStrategy,
-  failIfNoKiosk
+  failIfNoKiosk,
+  sharedKioskState
 }) => {
-  if (kioskTx) {
-    await runCommands(kioskTx);
+  if (sharedKioskState?.kioskTx) {
+    await runCommands(sharedKioskState.kioskTx);
     return;
   }
   if (!kioskOwner) {
     throw new Error("No kiosk owner provided");
   }
-  let kiosks = kioskOwnerKiosks ?? ((await gqlChainRequest({
+  let kioskTx;
+  let kiosks = sharedKioskState?.ownerKiosks ?? ((await gqlChainRequest({
     chain: "sui",
     query: fetchKiosksByOwner,
     variables: { ownerAddress: addLeadingZerosAfter0x(kioskOwner) }
   })).kiosks ?? []);
+  if (sharedKioskState) {
+    sharedKioskState.ownerKiosks = kiosks;
+  }
   if (shouldAssertNftInSharedKiosk) {
-    await assertNftInSharedKiosk({ kioskId: kiosk, walletAddress: kioskOwner, kiosks });
+    await assertNftInSharedKiosk({ kioskId: kiosk, walletAddress: kioskOwner, sharedKioskState });
   }
   kiosks = kiosks?.filter((k) => !k.is_origin_byte && (shouldAllowNftUnsharedKiosk || k.is_shared));
   if (kiosk) {
@@ -1559,8 +1562,11 @@ var kioskTxWrapper = async ({
     kioskTx = new import_kiosk3.KioskTransaction({ transactionBlock: tx, kioskClient });
     kioskTx.createPersonal(true);
   }
+  if (sharedKioskState) {
+    sharedKioskState.kioskTx = kioskTx;
+  }
   await runCommands(kioskTx);
-  if (!shouldSkipFinalize) {
+  if (!sharedKioskState?.kioskTx) {
     kioskTx.finalize();
   }
 };
@@ -1576,8 +1582,112 @@ var getKioskIdFromKioskTx = ({
   return kioskId;
 };
 
-// src/helpers/kiosk/resolveTransferPolicies.ts
+// src/helpers/kiosk/getTransferPoliciesToResolve.ts
 var import_kiosk4 = require("@mysten/kiosk");
+var originByteRuleModules = ["royalty_strategy_bps", "transfer_allowlist"];
+var getTransferPoliciesToResolve = async ({
+  transferPolicies,
+  suiClient,
+  kioskClient,
+  nftType,
+  customTransferPolicies
+}) => {
+  let policies = [];
+  if (transferPolicies.length > 0) {
+    const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+    if (transferPolicyId) {
+      const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
+        suiClient,
+        transferPolicyId
+      });
+      policies = [
+        {
+          id: transferPolicyId,
+          rules: ruleNames?.map((rule) => ({
+            rule
+          })),
+          isCustom: false
+        }
+      ];
+    }
+  } else {
+    const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
+      type: normalizedNftType(nftType)
+    });
+    if (transferPoliciesFromMystenSdk.length > 0) {
+      const policy = transferPoliciesFromMystenSdk.find(
+        (policy2) => policy2?.rules?.some(
+          (rule) => knownTransferPolicyRules.some((ruleType) => rule?.includes(ruleType))
+        )
+      ) ?? transferPoliciesFromMystenSdk[0];
+      policies = [
+        {
+          id: policy.id,
+          rules: policy.rules?.map((rule) => ({
+            rule
+          })),
+          isCustom: false
+        }
+      ];
+    } else {
+      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,
+        {
+          id: customPolicy[0].id,
+          rules: customPolicy[0].rules?.map((rule) => ({
+            rule
+          })),
+          isCustom: true,
+          type: customTransferPolicy?.type
+        }
+      ];
+    }
+  }
+  return policies.map((policy) => {
+    const kioskLockRule = policy?.rules.find(
+      (rule) => rule?.rule?.includes("kiosk_lock_rule")
+    );
+    const personalKioskRule = policy?.rules.find(
+      (rule) => rule.rule.includes("personal_kiosk_rule")
+    );
+    const otherRules = policy?.rules.filter(
+      (rule) => !rule?.rule?.includes("kiosk_lock_rule") && !rule?.rule?.includes("personal_kiosk_rule")
+    );
+    return {
+      ...policy,
+      rules: [kioskLockRule, personalKioskRule, ...otherRules].filter(Boolean)?.map((ruleData) => {
+        const ruleDefinition = kioskClient.rules.find(
+          (x) => (0, import_kiosk4.getNormalizedRuleType)(x.rule) === (0, import_kiosk4.getNormalizedRuleType)(ruleData.rule)
+        );
+        let rulePackageId = ruleDefinition?.packageId;
+        if (!rulePackageId) {
+          rulePackageId = ruleData?.rule?.split("::")?.[0];
+        }
+        const moduleName = ruleData?.rule?.split("::")?.[1];
+        if (originByteRuleModules.includes(moduleName)) {
+          throw new Error(
+            `Using Origin Byte rule ${ruleData.rule} inside the native kiosk transaction`
+          );
+        }
+        return {
+          ...ruleData,
+          rulePackageId,
+          moduleName
+        };
+      })
+    };
+  });
+};
 
 // src/helpers/kiosk/resolveFloorPriceRule.ts
 function resolveFloorPriceRule({ tx, packageId, nftType, policyId, transferRequest }) {
@@ -1685,19 +1795,23 @@ async function resolveRoyaltyRule({
   transferRequest,
   nftType,
   price,
-  coinToSplit
+  coinToSplit,
+  royaltyFeeAmount
 }) {
-  const royaltyFeeAmount = await getKioskCollectionRoyaltyFeeAmount({
-    tx,
-    suiClient,
-    walletAddress,
-    royaltyRulePackageId: packageId,
-    royaltyRuleModule: moduleName,
-    transferPolicyId: policyId,
-    price,
-    nftType
-  });
-  const feeCoin = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [royaltyFeeAmount]);
+  let feeAmount = royaltyFeeAmount;
+  if (!feeAmount) {
+    feeAmount = await getKioskCollectionRoyaltyFeeAmount({
+      tx,
+      suiClient,
+      walletAddress,
+      royaltyRulePackageId: packageId,
+      royaltyRuleModule: moduleName,
+      transferPolicyId: policyId,
+      price,
+      nftType
+    });
+  }
+  const feeCoin = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [feeAmount]);
   tx.moveCall({
     target: `${packageId}::${moduleName}::pay`,
     typeArguments: [nftType],
@@ -1706,7 +1820,6 @@ async function resolveRoyaltyRule({
 }
 
 // src/helpers/kiosk/resolveTransferPolicies.ts
-var originByteRuleModules = ["royalty_strategy_bps", "transfer_allowlist"];
 var resolveTransferPolicies = async ({
   tx,
   transferPolicies,
@@ -1723,102 +1836,28 @@ var resolveTransferPolicies = async ({
   shouldSkipKioskLocking,
   shouldSkipResolvingRoyaltyRule,
   coinToSplit,
-  beforeResolveKioskTransferRequest
+  beforeResolveKioskTransferRequest,
+  transferPoliciesToResolve,
+  royaltyFeeAmount
 }) => {
-  let policies = [];
-  if (transferPolicies.length > 0) {
-    const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
-    if (transferPolicyId) {
-      const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
-        suiClient,
-        transferPolicyId
-      });
-      policies = [
-        {
-          data: {
-            id: transferPolicyId,
-            rules: ruleNames
-          },
-          transferRequest,
-          isCustom: false
-        }
-      ];
-    }
-  } else {
-    const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
-      type: normalizedNftType(nftType)
-    });
-    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 ((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;
+  const policies = transferPoliciesToResolve ?? await getTransferPoliciesToResolve({
+    transferPolicies,
+    suiClient,
+    kioskClient,
+    nftType,
+    customTransferPolicies
+  });
+  let hasLockRule = false;
   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) {
+    for (const rule of policy.rules) {
+      switch (rule.moduleName) {
         case "kiosk_lock_rule":
-          canTransferOutsideKiosk = false;
+          hasLockRule = true;
           resolveKioskLockRule({
             tx,
-            packageId: rulePackageId,
-            policyId: policy.data.id,
-            transferRequest: policy.transferRequest,
+            packageId: rule.rulePackageId,
+            policyId: policy.id,
+            transferRequest,
             nftType: policy.isCustom && policy.type ? policy.type : nftType,
             kiosk: kioskToLockRuleProve ? kioskToLockRuleProve : kioskTx.kiosk,
             kioskCap: kioskTx.kioskCap,
@@ -1829,10 +1868,10 @@ var resolveTransferPolicies = async ({
         case "personal_kiosk_rule":
           resolvePersonalKioskRule({
             tx,
-            packageId: rulePackageId,
+            packageId: rule.rulePackageId,
             nftType: policy.isCustom && policy.type ? policy.type : nftType,
             kiosk: kioskTx.kiosk,
-            transferRequest: policy.transferRequest
+            transferRequest
           });
           break;
         case "royalty_rule":
@@ -1842,37 +1881,38 @@ var resolveTransferPolicies = async ({
             tx,
             suiClient,
             walletAddress,
-            packageId: rulePackageId,
-            moduleName,
-            policyId: policy.data.id,
-            transferRequest: policy.transferRequest,
+            packageId: rule.rulePackageId,
+            moduleName: rule.moduleName,
+            policyId: policy.id,
+            transferRequest,
             nftType: policy.isCustom && policy.type ? policy.type : nftType,
             price,
-            coinToSplit
+            coinToSplit,
+            royaltyFeeAmount
           });
           break;
         case "floor_price_rule":
           resolveFloorPriceRule({
             tx,
-            packageId: rulePackageId,
+            packageId: rule.rulePackageId,
             nftType: policy.isCustom && policy.type ? policy.type : nftType,
-            policyId: policy.data.id,
-            transferRequest: policy.transferRequest
+            policyId: policy.id,
+            transferRequest
           });
           break;
         default:
-          throw new Error(`No resolver for the following rule: ${rule}.`);
+          throw new Error(`No resolver for the following rule: ${rule.rule}.`);
       }
     }
   }
-  if (canTransferOutsideKiosk && kioskItem) {
+  if (!hasLockRule && 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],
+      arguments: [tx.object(policy.id), transferRequest],
       typeArguments: [policy.isCustom && policy.type ? policy.type : nftType]
     });
   }
@@ -2026,12 +2066,18 @@ var fetchWalletKiosks = import_graphql_request10.gql`
 `;
 
 // src/helpers/originByte/getOBKiosk.ts
-var getOBKiosk = async (wallet) => {
+var getOBKiosk = async ({
+  wallet,
+  sharedKioskState
+}) => {
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchWalletKiosks,
     variables: { wallet: addLeadingZerosAfter0x(wallet) }
   });
+  if (!sharedKioskState?.ownerKiosks) {
+    sharedKioskState.ownerKiosks = res?.kiosks;
+  }
   return res?.kiosks?.filter((kiosk) => kiosk?.is_origin_byte && kiosk?.is_shared)?.[0]?.id;
 };
 
@@ -2040,7 +2086,8 @@ var getOrCreateOBKiosk = async ({
   tx,
   address,
   kioskToUseIfExists,
-  createMethod
+  createMethod,
+  sharedKioskState
 }) => {
   if (kioskToUseIfExists) {
     return {
@@ -2048,12 +2095,14 @@ var getOrCreateOBKiosk = async ({
       isNewKiosk: false
     };
   }
-  const existingKiosk = await getOBKiosk(address);
-  if (existingKiosk) {
-    return {
-      kiosk: existingKiosk,
-      isNewKiosk: false
-    };
+  if (!sharedKioskState?.ownerKiosks) {
+    const existingKiosk = await getOBKiosk({ wallet: address, sharedKioskState });
+    if (existingKiosk) {
+      return {
+        kiosk: existingKiosk,
+        isNewKiosk: false
+      };
+    }
   }
   const [newKiosk] = await createOBKiosk({ tx, createMethod });
   return {
@@ -2073,7 +2122,7 @@ var isOriginByteCollection = (transferPolicies) => {
 };
 
 // src/helpers/originByte/shareOriginByteKiosk.ts
-var shareOriginByteKiosk = async ({ tx, kiosk }) => {
+var shareOriginByteKiosk = ({ tx, kiosk }) => {
   tx.moveCall({
     target: "0x2::transfer::public_share_object",
     arguments: [tx.object(kiosk)],
@@ -2375,7 +2424,7 @@ function addBluemoveAcceptNftBidTx({
   });
 }
 async function addSingleBidAcceptNftBidTx(txData) {
-  const { nftType, tx, bidNonce, multiBidId, kioskClient, nftTokenId, suiClient } = txData;
+  const { nftType, tx, bidNonce, multiBidId, nftTokenId, suiClient, sharedKioskState } = txData;
   const transferPolicies = getNativeKioskTransferPolicies(txData?.transferPolicies);
   const transferPolicy = transferPolicies?.find(
     (policy) => policy?.rules?.length > 0
@@ -2388,17 +2437,11 @@ async function addSingleBidAcceptNftBidTx(txData) {
   if (multiBidChainId && cancelled_at) {
     throw new Error(`MultiBid ${multiBidId} already cancelled`);
   }
-  if (transferPolicy && txData.sellerKiosk) {
-    const transferPolicies2 = await kioskClient.getTransferPolicies({
-      type: (0, import_utils3.normalizeStructTag)(nftType)
+  if (transferPolicy) {
+    const allRules = await getTransferPolicyRuleNamesFromSuiObject({
+      suiClient,
+      transferPolicyId: 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))
     );
@@ -2410,9 +2453,9 @@ async function addSingleBidAcceptNftBidTx(txData) {
     return kioskTxWrapper({
       tx: txData?.tx,
       kioskClient: txData?.kioskClient,
-      kioskTx: txData?.kioskTx,
       kioskOwner: txData?.seller,
       kiosk: txData?.sellerKiosk,
+      sharedKioskState,
       async runCommands(kioskTx) {
         const [transferRequest] = tx.moveCall({
           target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::accept_bid_with_transfer_policy`,
@@ -2483,12 +2526,12 @@ async function addTradePortAcceptNftBidTxHandler(txData) {
       return kioskTxWrapper({
         tx: txData?.tx,
         kioskClient: txData?.kioskClient,
-        kioskTx: txData?.kioskTx,
         kioskOwner: txData?.itemOwner,
         kiosk: txData?.sellerKiosk,
         shouldConvertToPersonalKiosk: Boolean(hasPersonalKioskRule(txData?.transferPolicies)),
         shouldAssertNftInSharedKiosk: true,
         failIfNoKiosk: true,
+        sharedKioskState: txData?.sharedKioskState,
         async runCommands(kioskTx) {
           await addTradeportKioskAcceptNftBidTx({
             ...txData,
@@ -2656,6 +2699,7 @@ async function addTradePortUnlistTxHandler(txData) {
       kioskOwner: txData?.seller,
       kiosk: txData?.sellerKiosk,
       shouldAllowNftUnsharedKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         await addTradePortKioskUnlistTx({
           ...txData,
@@ -2694,6 +2738,7 @@ async function addHyperspaceUnlistTxHandler(txData) {
     kioskOwner: txData?.seller,
     kiosk: txData?.sellerKiosk,
     shouldAllowNftUnsharedKiosk: true,
+    sharedKioskState: txData?.sharedKioskState,
     async runCommands(kioskTx) {
       await addHyperspaceKioskUnlistTx({
         ...txData,
@@ -2715,6 +2760,7 @@ async function addBluemoveUnlistTxHandler(txData) {
       kioskOwner: txData?.seller,
       kiosk: txData?.sellerKiosk,
       shouldAllowNftUnsharedKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         await addBluemoveKioskUnlistTx({
           ...txData,
@@ -2843,7 +2889,7 @@ async function addOriginByteAcceptCollectionBidTx(txData) {
   });
   confirmOBTranfer({ tx, sharedObjects, transferRequest, nftType });
   if (isNewKiosk) {
-    await shareOriginByteKiosk({ tx, kiosk });
+    shareOriginByteKiosk({ tx, kiosk });
   }
 }
 function addBluemoveAcceptCollectionBidTx({
@@ -2937,10 +2983,10 @@ async function addTradePortAcceptCollectionBidTxHandler(txData) {
     return kioskTxWrapper({
       tx: txData?.tx,
       kioskClient: txData?.kioskClient,
-      kioskTx: txData?.kioskTx,
       kioskOwner: txData?.seller,
       kiosk: txData?.sellerKiosk,
       shouldAssertNftInSharedKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         const borrowedItem = await takeAndBorrowNftFromKiosk({
           tx: txData?.tx,
@@ -2968,12 +3014,12 @@ async function addTradePortAcceptCollectionBidTxHandler(txData) {
     return kioskTxWrapper({
       tx: txData?.tx,
       kioskClient: txData?.kioskClient,
-      kioskTx: txData?.kioskTx,
       kioskOwner: txData?.itemOwner,
       kiosk: txData?.sellerKiosk,
       shouldConvertToPersonalKiosk: Boolean(hasPersonalKioskRule(txData?.transferPolicies)),
       shouldAssertNftInSharedKiosk: true,
       failIfNoKiosk: Boolean(txData?.sellerKiosk),
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         await addTradeportKioskAcceptCollectionBidTx({
           ...txData,
@@ -3004,10 +3050,10 @@ async function addBluemoveAcceptCollectionBidTxHandler(txData) {
       return kioskTxWrapper({
         tx: txData?.tx,
         kioskClient: txData?.kioskClient,
-        kioskTx: txData?.kioskTx,
         kioskOwner: txData?.itemOwner,
         kiosk: txData?.sellerKiosk,
         shouldAssertNftInSharedKiosk: true,
+        sharedKioskState: txData?.sharedKioskState,
         async runCommands(kioskTx) {
           await addBluemoveKioskAcceptCollectionBidTx({
             ...txData,
@@ -3025,10 +3071,10 @@ async function addBluemoveAcceptCollectionBidTxHandler(txData) {
       return kioskTxWrapper({
         tx: txData?.tx,
         kioskClient: txData?.kioskClient,
-        kioskTx: txData?.kioskTx,
         kioskOwner: txData?.itemOwner,
         kiosk: txData?.sellerKiosk,
         shouldAssertNftInSharedKiosk: true,
+        sharedKioskState: txData?.sharedKioskState,
         async runCommands(kioskTx) {
           const borrowedItem = await takeAndBorrowNftFromKiosk({
             tx: txData?.tx,
@@ -3076,6 +3122,9 @@ var acceptCollectionBid = async ({
   }
   const bidsForTracking = [];
   const tx = existingTx ?? new import_transactions2.Transaction();
+  const sharedKioskState = {
+    kioskTx: kioskTx ?? void 0
+  };
   const nftType = getNftType({
     collectionId: nft?.collection_id,
     collectionChainState: nft?.collection?.chain_state,
@@ -3088,6 +3137,7 @@ var acceptCollectionBid = async ({
     transferPolicies,
     suiClient: context.suiClient,
     kioskClient: context.kioskClient,
+    sharedKioskState,
     bidNonce: bid?.nonce,
     nftType,
     nftTokenId: nft?.token_id,
@@ -3202,6 +3252,9 @@ var acceptNftBids = async ({
   }
   const bidsForTracking = [];
   const tx = existingTx ?? new import_transactions3.Transaction();
+  const sharedKioskState = {
+    kioskTx: kioskTx ?? void 0
+  };
   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);
@@ -3224,6 +3277,7 @@ var acceptNftBids = async ({
     const txData = {
       tx,
       kioskTx,
+      sharedKioskState,
       transferPolicies,
       suiClient: context.suiClient,
       kioskClient: context.kioskClient,
@@ -3618,17 +3672,18 @@ async function buyAndExerciseLongLocks({ walletAddress, locks, tx: existingTx },
 }
 
 // src/methods/buyAndExerciseShortLocks/buyAndExerciseShortLocks.ts
-var import_transactions9 = require("@mysten/sui/transactions");
+var import_transactions10 = require("@mysten/sui/transactions");
 
 // src/methods/exerciseShortLocks/exerciseShortLocks.ts
 var import_utils7 = require("@mysten/sui.js/utils");
-var import_transactions8 = require("@mysten/sui/transactions");
+var import_transactions9 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchListingsById.ts
 var import_graphql_request15 = require("graphql-request");
 var fetchListingsById = import_graphql_request15.gql`
 	query fetchListingsById($listingIds: [uuid!]) {
 		listings(where: { id: { _in: $listingIds } }) {
+			id
 			seller
 			listed
 			market_name
@@ -3654,7 +3709,7 @@ var fetchListingsById = import_graphql_request15.gql`
 `;
 
 // src/methods/buyListings/buyListings.ts
-var import_transactions7 = require("@mysten/sui/transactions");
+var import_transactions8 = require("@mysten/sui/transactions");
 
 // src/helpers/addThirdPartyTxFee.ts
 var addThirdPartyTxFee = async (tx, price) => {
@@ -3667,8 +3722,109 @@ var addThirdPartyTxFee = async (tx, price) => {
   );
 };
 
-// src/methods/buyListings/addBuyListingTxs.ts
+// src/helpers/kiosk/preProcessSharedBulkBuyingData.ts
 var import_bcs2 = require("@mysten/sui/bcs");
+var import_transactions7 = require("@mysten/sui/transactions");
+var preProcessSharedBulkBuyingData = async ({
+  listings,
+  suiClient,
+  kioskClient,
+  walletAddress
+}) => {
+  const sharedBulkBuyingDataByNftType = {};
+  const listingsByNftType = listings.reduce(
+    (acc, listing) => {
+      const nftType = getNftType({
+        collectionId: listing?.collection?.id,
+        collectionChainState: listing?.collection?.chain_state,
+        nft: listing?.nft
+      });
+      acc[nftType] = [...acc[nftType] || [], listing];
+      return acc;
+    },
+    {}
+  );
+  for (const nftType of Object.keys(listingsByNftType)) {
+    sharedBulkBuyingDataByNftType[nftType] = {
+      sharedObjects: [],
+      transferPoliciesToResolve: [],
+      royaltyFeeAmountsByListingId: {},
+      commissionFeeAmountsByListingId: {}
+    };
+    const transferPolicies = listingsByNftType[nftType]?.[0]?.collection?.chain_state?.transfer_policies;
+    if (isOriginByteCollection(transferPolicies)) {
+      sharedBulkBuyingDataByNftType[nftType].sharedObjects = await getSharedObjects(nftType);
+      continue;
+    }
+    const tradeportKioskListings = listingsByNftType[nftType]?.filter(
+      (listing) => listing.market_name === "tradeport" && listing.price && listing.listed && !(listing?.nonce && isOriginByteCollection(transferPolicies)) && listing.nft?.chain_state?.kiosk_id
+    );
+    if (tradeportKioskListings.length === 0) {
+      continue;
+    }
+    const transferPoliciesToResolve = await getTransferPoliciesToResolve({
+      transferPolicies,
+      suiClient,
+      kioskClient,
+      nftType
+    });
+    sharedBulkBuyingDataByNftType[nftType].transferPoliciesToResolve = transferPoliciesToResolve;
+    const transferPolicyToResolve = transferPoliciesToResolve.at(0);
+    const royaltyRuleToResolve = transferPolicyToResolve.rules.find(
+      (policy) => policy.moduleName === "royalty_rule" || policy.moduleName === "kiosk_royalty_rule"
+    );
+    if (royaltyRuleToResolve?.rulePackageId && royaltyRuleToResolve?.moduleName) {
+      const feeTx = new import_transactions7.Transaction();
+      for (const listing of tradeportKioskListings) {
+        feeTx.moveCall({
+          target: `${royaltyRuleToResolve.rulePackageId}::${royaltyRuleToResolve.moduleName}::fee_amount`,
+          arguments: [feeTx.object(transferPolicyToResolve?.id), feeTx.pure.u64(listing.price)],
+          typeArguments: [nftType]
+        });
+      }
+      const res = await suiClient.devInspectTransactionBlock({
+        sender: addLeadingZerosAfter0x(walletAddress),
+        transactionBlock: feeTx
+      });
+      for (let i = 0; i < res.results.length; i++) {
+        const result = res.results[i];
+        const returnedAmount = result?.returnValues?.[0]?.[0];
+        const feeAmount = BigInt(import_bcs2.bcs.U64.parse(new Uint8Array(returnedAmount)));
+        if (!feeAmount && feeAmount !== 0n) {
+          continue;
+        }
+        sharedBulkBuyingDataByNftType[nftType].royaltyFeeAmountsByListingId[tradeportKioskListings[i].id] = feeAmount;
+      }
+    }
+    const batchSize = 10;
+    const commissionResults = [];
+    for (let i = 0; i < tradeportKioskListings.length; i += batchSize) {
+      const batch = tradeportKioskListings.slice(i, i + batchSize);
+      const batchPromises = batch.map(async (listing) => {
+        const response = await suiClient.getDynamicFieldObject({
+          parentId: TRADEPORT_KIOSK_LISTING_STORE,
+          name: { type: "0x2::object::ID", value: listing.nft.token_id }
+        });
+        if (response.error?.code === "dynamicFieldNotFound") {
+          throw new Error(`Not found kiosk listing object of token ${listing.nft.token_id}`);
+        }
+        return {
+          listingId: listing.id,
+          commission: Number(response.data.content.fields.commission)
+        };
+      });
+      const batchResults = await Promise.all(batchPromises);
+      commissionResults.push(...batchResults);
+    }
+    for (const result of commissionResults) {
+      sharedBulkBuyingDataByNftType[nftType].commissionFeeAmountsByListingId[result.listingId] = result.commission;
+    }
+  }
+  return sharedBulkBuyingDataByNftType;
+};
+
+// src/methods/buyListings/addBuyListingTxs.ts
+var import_bcs3 = require("@mysten/sui/bcs");
 
 // src/graphql/queries/fetchCommissionByListingId.ts
 var import_graphql_request16 = require("graphql-request");
@@ -3749,24 +3905,33 @@ var addTradeportKioskBuyTx = async ({
   kioskTx,
   suiClient,
   kioskClient,
+  listingId,
   nftType,
   nftTokenId,
   price,
   sellerKiosk,
   seller,
   coinToSplit,
-  beforeResolveKioskTransferRequest
+  beforeResolveKioskTransferRequest,
+  sharedBulkBuyingDataByNftType,
+  collectionId
 }) => {
-  await assertNftInSharedKiosk({ kioskId: sellerKiosk, walletAddress: seller });
-  const response = await suiClient.getDynamicFieldObject({
-    parentId: TRADEPORT_KIOSK_LISTING_STORE,
-    name: { type: "0x2::object::ID", value: nftTokenId }
-  });
-  if (response.error?.code === "dynamicFieldNotFound") {
-    throw new Error(`Not found kiosk listing object of token ${nftTokenId}`);
+  let commissionFeeAmount = sharedBulkBuyingDataByNftType?.[nftType]?.commissionFeeAmountsByListingId?.[listingId] ?? 0;
+  if (!commissionFeeAmount) {
+    const response = await suiClient.getDynamicFieldObject({
+      parentId: TRADEPORT_KIOSK_LISTING_STORE,
+      name: { type: "0x2::object::ID", value: nftTokenId }
+    });
+    if (response.error?.code === "dynamicFieldNotFound") {
+      throw new Error(`Not found kiosk listing object of token ${nftTokenId}`);
+    }
+    commissionFeeAmount = Number(response.data?.content?.fields?.commission);
+  }
+  if (commissionFeeAmount === 0) {
+    commissionFeeAmount = getMarketFeePrice({ price, collectionId });
   }
   const coin = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [
-    tx.pure.u64(price + Number(response.data.content.fields.commission))
+    tx.pure.u64(price + commissionFeeAmount)
   ]);
   if (!coin) throw new Error("Coin could not be split");
   const [kioskItem, transferRequest] = tx.moveCall({
@@ -3774,7 +3939,7 @@ var addTradeportKioskBuyTx = async ({
     arguments: [
       tx.object(TRADEPORT_KIOSK_LISTING_STORE),
       tx.object(sellerKiosk),
-      tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      tx.object("value" in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk),
       tx.pure.address(nftTokenId),
       tx.object(coin)
     ],
@@ -3792,7 +3957,9 @@ var addTradeportKioskBuyTx = async ({
     kioskItem,
     transferRequest,
     coinToSplit,
-    beforeResolveKioskTransferRequest
+    beforeResolveKioskTransferRequest,
+    transferPoliciesToResolve: sharedBulkBuyingDataByNftType?.[nftType]?.transferPoliciesToResolve,
+    royaltyFeeAmount: sharedBulkBuyingDataByNftType?.[nftType]?.royaltyFeeAmountsByListingId?.[listingId]
   });
   destroyZeroCoin({ tx, coin });
 };
@@ -3805,13 +3972,19 @@ async function addOriginByteBuyTx({
   nftTokenId,
   nftType,
   listingNonce,
-  price
+  price,
+  sharedKioskState
 }) {
-  await assertNftInSharedKiosk({ kioskId: sellerKiosk, walletAddress: seller });
+  await assertNftInSharedKiosk({
+    kioskId: sellerKiosk,
+    walletAddress: seller,
+    sharedKioskState
+  });
   const { orderbook } = sharedObjects;
   const { kiosk: buyerKiosk, isNewKiosk: isNewBuyerKiosk } = await getOrCreateOBKiosk({
     tx,
-    address: buyer
+    address: buyer,
+    sharedKioskState
   });
   const [coin] = splitCoins({ tx, amounts: [tx.pure.u64(price)] });
   if (!coin) throw new Error("Coin could not be split");
@@ -3830,7 +4003,7 @@ async function addOriginByteBuyTx({
   confirmOBTranfer({ tx, sharedObjects, transferRequest, nftType });
   destroyZeroCoin({ tx, coin });
   if (isNewBuyerKiosk) {
-    await shareOriginByteKiosk({ tx, kiosk: buyerKiosk });
+    shareOriginByteKiosk({ tx, kiosk: buyerKiosk });
   }
 }
 var addHyperspaceKioskBuyTx = async ({
@@ -3846,7 +4019,6 @@ var addHyperspaceKioskBuyTx = async ({
   seller,
   beforeResolveKioskTransferRequest
 }) => {
-  await assertNftInSharedKiosk({ kioskId: sellerKiosk, walletAddress: seller });
   const [coin] = splitCoins({ tx, amounts: [tx.pure.u64(price)] });
   if (!coin) throw new Error("Coin could not be split");
   const [kioskItem, transferRequest, hyperspaceTransferRequest, hyperspaceMpTransferRequest] = tx.moveCall({
@@ -3863,7 +4035,7 @@ var addHyperspaceKioskBuyTx = async ({
       type: HYPERSPACE_MP_TRANSFER_POLICY_TYPE,
       transferRequest: hyperspaceMpTransferRequest
     }
-  ];
+  ].filter((customTransferPolicy) => customTransferPolicy.transferRequest !== transferRequest);
   await beforeResolveKioskTransferRequest?.(transferRequest);
   await resolveTransferPolicies({
     tx,
@@ -3908,7 +4080,6 @@ async function addBluemoveKioskBuyTx({
   seller,
   beforeResolveKioskTransferRequest
 }) {
-  await assertNftInSharedKiosk({ kioskId: sellerKiosk, walletAddress: seller });
   const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
   const [coin1, coin2] = splitCoins({
     tx,
@@ -3922,7 +4093,7 @@ async function addBluemoveKioskBuyTx({
       tx.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
       tx.object(sellerKiosk),
       tx.object(transferPolicyId),
-      tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      tx.object("value" in kioskTx.kiosk ? kioskTx.kiosk.value : kioskTx.kiosk),
       tx.pure.address(nftTokenId),
       tx.pure.u64(price),
       tx.object(coin1)
@@ -4062,7 +4233,7 @@ var addTocenBuyTx = ({ tx, nftTokenIds, nftType, price }) => {
     target: "0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::buy_cart",
     arguments: [
       tx.object(TOCEN_MARKETPLACE_OBJECT),
-      tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.Address).serialize(nftTokenIds)),
+      tx.pure(import_bcs3.bcs.vector(import_bcs3.bcs.Address).serialize(nftTokenIds)),
       tx.object(coin)
     ],
     typeArguments: [nftType]
@@ -4070,7 +4241,7 @@ var addTocenBuyTx = ({ tx, nftTokenIds, nftType, price }) => {
 };
 async function addTradePortBuyTxHandler(txData) {
   if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies)) {
-    const sharedObjects2 = await getSharedObjects(txData?.nftType);
+    const sharedObjects2 = txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ?? await getSharedObjects(txData?.nftType);
     await addOriginByteBuyTx({ ...txData, sharedObjects: sharedObjects2 });
     return;
   }
@@ -4083,7 +4254,7 @@ async function addTradePortBuyTxHandler(txData) {
       throw new Error(response.error.code);
     }
     if (response.data.type === NON_KIOSK_LISTING_NONCE_TYPE) {
-      const sharedObjects2 = await getSharedObjects(txData?.nftType);
+      const sharedObjects2 = txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ?? await getSharedObjects(txData?.nftType);
       addTradePortBuyTx({ ...txData, sharedObjects: sharedObjects2 });
       return;
     }
@@ -4092,10 +4263,10 @@ async function addTradePortBuyTxHandler(txData) {
     return kioskTxWrapper({
       tx: txData?.tx,
       kioskClient: txData?.kioskClient,
-      kioskTx: txData?.kioskTx,
       kioskOwner: txData?.buyer,
       kiosk: txData?.sellerKiosk,
       shouldConvertToPersonalKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         await addTradeportKioskBuyTx({
           ...txData,
@@ -4104,22 +4275,22 @@ async function addTradePortBuyTxHandler(txData) {
       }
     });
   }
-  const sharedObjects = await getSharedObjects(txData?.nftType);
+  const sharedObjects = txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ?? await getSharedObjects(txData?.nftType);
   addTradePortBuyTx({ ...txData, sharedObjects });
 }
 async function addHyperspaceBuyTxHandler(txData) {
   if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies)) {
-    const sharedObjects = await getSharedObjects(txData?.nftType);
+    const sharedObjects = txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ?? await getSharedObjects(txData?.nftType);
     await addOriginByteBuyTx({ ...txData, sharedObjects });
     return;
   }
   return kioskTxWrapper({
     tx: txData?.tx,
     kioskClient: txData?.kioskClient,
-    kioskTx: txData?.kioskTx,
     kioskOwner: txData?.buyer,
     kiosk: txData?.sellerKiosk,
     shouldConvertToPersonalKiosk: true,
+    sharedKioskState: txData?.sharedKioskState,
     async runCommands(kioskTx) {
       await addHyperspaceKioskBuyTx({
         ...txData,
@@ -4130,7 +4301,7 @@ async function addHyperspaceBuyTxHandler(txData) {
 }
 async function addBluemoveBuyTxHandler(txData) {
   if (txData?.listingNonce && isOriginByteCollection(txData?.transferPolicies)) {
-    const sharedObjects = await getSharedObjects(txData?.nftType);
+    const sharedObjects = txData?.sharedBulkBuyingDataByNftType?.[txData?.nftType]?.sharedObjects ?? await getSharedObjects(txData?.nftType);
     await addOriginByteBuyTx({ ...txData, sharedObjects });
     return;
   }
@@ -4138,10 +4309,10 @@ async function addBluemoveBuyTxHandler(txData) {
     return kioskTxWrapper({
       tx: txData?.tx,
       kioskClient: txData?.kioskClient,
-      kioskTx: txData?.kioskTx,
       kioskOwner: txData?.buyer,
       kiosk: txData?.sellerKiosk,
       shouldConvertToPersonalKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         await addBluemoveKioskBuyTx({
           ...txData,
@@ -4194,10 +4365,22 @@ var buyListings = async ({
     throw new Error("No listings found");
   }
   const listingsForTracking = [];
-  const tx = existingTx ?? new import_transactions7.Transaction();
+  const tx = existingTx ?? new import_transactions8.Transaction();
   const tocenTokenIds = [];
   let tocenNftType = "";
   let tocenTotalPrice = 0;
+  const sharedKioskState = {
+    kioskTx: kioskTx ?? void 0
+  };
+  let sharedBulkBuyingDataByNftType;
+  if (res.listings.length > 1) {
+    sharedBulkBuyingDataByNftType = await preProcessSharedBulkBuyingData({
+      listings: res.listings,
+      suiClient: context.suiClient,
+      kioskClient: context.kioskClient,
+      walletAddress
+    });
+  }
   for (const listing of res.listings) {
     if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(listing?.nft?.token_id)) {
       throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
@@ -4229,7 +4412,9 @@ var buyListings = async ({
       nftContractId: listing?.nft?.contract_id,
       coinToSplit,
       marketFeeDecimalPercent,
-      beforeResolveKioskTransferRequest
+      beforeResolveKioskTransferRequest,
+      sharedKioskState,
+      sharedBulkBuyingDataByNftType
     };
     switch (listing?.market_name) {
       case "tradeport":
@@ -4273,6 +4458,7 @@ var buyListings = async ({
       marketName: listing?.market_name
     });
   }
+  sharedKioskState?.kioskTx?.finalize();
   if (tocenTokenIds?.length > 0) {
     addTocenBuyTxHandler({
       tx,
@@ -4281,12 +4467,12 @@ var buyListings = async ({
       price: tocenTotalPrice
     });
   }
-  return import_transactions7.Transaction.from(tx);
+  return import_transactions8.Transaction.from(tx);
 };
 
 // src/methods/exerciseShortLocks/exerciseShortLocks.ts
 async function exerciseShortLocks({ walletAddress, transaction, locks }, context) {
-  const tx = transaction ?? new import_transactions8.Transaction();
+  const tx = transaction ?? new import_transactions9.Transaction();
   for (const { id: lockId, listingId, nftId: nftIdArg } of locks) {
     const lock = await getLockById(lockId);
     if (!transaction && lock.state !== "bought") {
@@ -4424,7 +4610,7 @@ async function exerciseShortLocks({ walletAddress, transaction, locks }, context
 
 // src/methods/buyAndExerciseShortLocks/buyAndExerciseShortLocks.ts
 async function buyAndExerciseShortLocks({ walletAddress, locks, tx: existingTx }, context) {
-  const transaction = existingTx ?? new import_transactions9.Transaction();
+  const transaction = existingTx ?? new import_transactions10.Transaction();
   await buyLocks({ lockIds: locks?.map((lock) => lock?.id), transaction }, context);
   await exerciseShortLocks({ locks, walletAddress, transaction }, context);
   return transaction;
@@ -4432,9 +4618,9 @@ async function buyAndExerciseShortLocks({ walletAddress, locks, tx: existingTx }
 
 // src/methods/cancelLocks/cancelLocks.ts
 var import_utils8 = require("@mysten/sui.js/utils");
-var import_transactions10 = require("@mysten/sui/transactions");
+var import_transactions11 = require("@mysten/sui/transactions");
 async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, context) {
-  const tx = existingTx ?? new import_transactions10.Transaction();
+  const tx = existingTx ?? new import_transactions11.Transaction();
   for (const lockId of lockIds) {
     const lock = await getLockById(lockId);
     if (!lock) {
@@ -4466,7 +4652,7 @@ async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, context)
 }
 
 // src/methods/cancelMultiBid/cancelMultiBid.ts
-var import_transactions11 = require("@mysten/sui/transactions");
+var import_transactions12 = require("@mysten/sui/transactions");
 async function cancelMultiBid({ multiBidId }) {
   const { chain_id: multiBidChainId, cancelled_at } = (await gqlChainRequest({
     chain: "sui",
@@ -4479,7 +4665,7 @@ async function cancelMultiBid({ multiBidId }) {
   if (cancelled_at) {
     throw new Error(`MultiBid ${multiBidId} already cancelled`);
   }
-  const tx = new import_transactions11.Transaction();
+  const tx = new import_transactions12.Transaction();
   tx.moveCall({
     target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::cancel_multi_bid`,
     arguments: [tx.object(TRADEPORT_MULTI_BID_STORE), tx.pure.id(multiBidChainId)]
@@ -4488,7 +4674,7 @@ async function cancelMultiBid({ multiBidId }) {
 }
 
 // src/methods/cancelNftTransfers/cancelNftTransfers.ts
-var import_transactions12 = require("@mysten/sui/transactions");
+var import_transactions13 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchAccountKiosks.ts
 var import_graphql_request17 = require("graphql-request");
@@ -4542,7 +4728,10 @@ var cancelNftTransfers = async ({ nftIds, walletAddress }, context) => {
     throw new Error("No nfts found");
   }
   const nftsForTracking = [];
-  const tx = new import_transactions12.Transaction();
+  const tx = new import_transactions13.Transaction();
+  const sharedKioskState = {
+    kioskTx: void 0
+  };
   for (const nft of res.nfts) {
     if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(nft?.token_id)) {
       throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
@@ -4558,6 +4747,7 @@ var cancelNftTransfers = async ({ nftIds, walletAddress }, context) => {
     const sharedObjects = await getSharedObjects(nftType);
     const txData = {
       tx,
+      sharedKioskState,
       nftType,
       nftTokenId: nft?.token_id,
       senderKiosk: nft?.chain_state?.kiosk_id,
@@ -4574,16 +4764,18 @@ var cancelNftTransfers = async ({ nftIds, walletAddress }, context) => {
       kioskOwner: txData?.senderAddress,
       kiosk: txData?.senderKiosk,
       shouldAllowNftUnsharedKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         await addTradeportKioskCancelNftTransferTx({ ...txData, kioskTx });
       }
     });
   }
-  return import_transactions12.Transaction.from(tx);
+  sharedKioskState?.kioskTx?.finalize();
+  return import_transactions13.Transaction.from(tx);
 };
 
 // src/methods/claimNfts/claimNfts.ts
-var import_transactions13 = require("@mysten/sui/transactions");
+var import_transactions14 = require("@mysten/sui/transactions");
 
 // src/methods/claimNfts/addClaimNftsTxs.ts
 var addClaimTradeHoldTx = ({
@@ -4802,16 +4994,11 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
     throw new Error("No nfts found");
   }
   const nftsForTracking = [];
-  const tx = existingTx ?? new import_transactions13.Transaction();
-  const kiosksByOwnerRes = await gqlChainRequest({
-    chain: "sui",
-    query: fetchKiosksByOwner,
-    variables: { ownerAddress: addLeadingZerosAfter0x(walletAddress) }
-  });
-  const walletAddressKiosks = kiosksByOwnerRes?.kiosks;
-  let globalKioskTx;
+  const tx = existingTx ?? new import_transactions14.Transaction();
+  const sharedKioskState = {
+    kioskTx: void 0
+  };
   for (const nft of res.nfts) {
-    let existingKioskTx;
     if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(nft?.token_id)) {
       throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
     }
@@ -4835,7 +5022,8 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
         nftType,
         claimableTradeId: nft?.chain_state?.claimable_trade_id,
         claimableSellerKiosk: nft?.chain_state?.claimable_seller_kiosk,
-        claimableBuyerKiosk: nft?.chain_state?.claimable_buyer_kiosk
+        claimableBuyerKiosk: nft?.chain_state?.claimable_buyer_kiosk,
+        sharedKioskState
       };
       const sharedObjects = await getSharedObjects(nftType);
       addClaimTradeHoldTx({ ...txData, sharedObjects });
@@ -4848,6 +5036,7 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
         tx,
         suiClient: context.suiClient,
         kioskClient: context.kioskClient,
+        sharedKioskState,
         transferPolicies,
         claimer: walletAddress,
         nftType,
@@ -4860,14 +5049,11 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
           tx,
           kioskClient: context.kioskClient,
           kioskOwner: txData?.claimer,
-          kioskOwnerKiosks: walletAddressKiosks,
           kiosk: txData?.sellerKiosk,
-          kioskTx: globalKioskTx,
           shouldConvertToPersonalKiosk: true,
           shouldAllowNftUnsharedKiosk: true,
-          shouldSkipFinalize: true,
+          sharedKioskState,
           async runCommands(kioskTx) {
-            existingKioskTx = kioskTx;
             await addBluemoveClaimAcceptedBidNft({
               ...txData,
               suiClient: context.suiClient,
@@ -4875,7 +5061,6 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
             });
           }
         });
-        globalKioskTx = existingKioskTx;
         continue;
       }
       if (useOldClaim) {
@@ -4883,14 +5068,11 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
           tx,
           kioskClient: context.kioskClient,
           kioskOwner: txData?.claimer,
-          kioskOwnerKiosks: walletAddressKiosks,
           kiosk: txData?.sellerKiosk,
-          kioskTx: globalKioskTx,
           shouldConvertToPersonalKiosk: true,
           shouldAllowNftUnsharedKiosk: true,
-          shouldSkipFinalize: true,
+          sharedKioskState,
           async runCommands(kioskTx) {
-            existingKioskTx = kioskTx;
             await addClaimAcceptedBidNftTx({ ...txData, kioskTx });
           }
         });
@@ -4899,19 +5081,15 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
           tx,
           kioskClient: context.kioskClient,
           kioskOwner: txData?.claimer,
-          kioskOwnerKiosks: walletAddressKiosks,
           kiosk: txData?.sellerKiosk,
-          kioskTx: globalKioskTx,
           shouldConvertToPersonalKiosk: true,
           shouldAssertNftInSharedKiosk: true,
-          shouldSkipFinalize: true,
+          sharedKioskState,
           async runCommands(kioskTx) {
-            existingKioskTx = kioskTx;
             await addClaimAcceptedBidNftWithPurchaseCapTx({ ...txData, kioskTx });
           }
         });
       }
-      globalKioskTx = existingKioskTx;
       continue;
     }
     if (nft?.chain_state?.claimable_reason === "offer-transfer") {
@@ -4924,7 +5102,8 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
         nftType,
         nftTokenId: nft?.token_id,
         sellerKiosk: nft?.chain_state?.kiosk_id,
-        seller: nft?.owner
+        seller: nft?.owner,
+        sharedKioskState
       };
       if (useOldClaim) {
         await kioskTxWrapper({
@@ -4932,14 +5111,11 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
           kioskClient: context.kioskClient,
           kioskOwner: txData?.claimer,
           kiosk: txData?.sellerKiosk,
-          kioskOwnerKiosks: walletAddressKiosks,
           kioskStrategy: "exclude",
-          kioskTx: globalKioskTx,
           shouldConvertToPersonalKiosk: true,
           shouldAllowNftUnsharedKiosk: true,
-          shouldSkipFinalize: true,
+          sharedKioskState,
           async runCommands(kioskTx) {
-            existingKioskTx = kioskTx;
             await addClaimTransferredNftTx({ ...txData, kioskTx });
           }
         });
@@ -4949,27 +5125,23 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
           kioskClient: context.kioskClient,
           kioskOwner: txData?.claimer,
           kiosk: txData?.sellerKiosk,
-          kioskOwnerKiosks: walletAddressKiosks,
           kioskStrategy: "exclude",
-          kioskTx: globalKioskTx,
           shouldConvertToPersonalKiosk: true,
           shouldAllowNftUnsharedKiosk: true,
-          shouldSkipFinalize: true,
+          sharedKioskState,
           async runCommands(kioskTx) {
-            existingKioskTx = kioskTx;
             await addClaimTransferredNftWithPurchaseCapTx({ ...txData, kioskTx });
           }
         });
       }
     }
-    globalKioskTx = existingKioskTx;
   }
-  globalKioskTx?.finalize();
-  return import_transactions13.Transaction.from(tx);
+  sharedKioskState?.kioskTx?.finalize();
+  return import_transactions14.Transaction.from(tx);
 };
 
 // src/methods/createLongLocks/createLongLocks.ts
-var import_transactions14 = require("@mysten/sui/transactions");
+var import_transactions15 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchActiveLockStateByNftId.ts
 var import_graphql_request18 = require("graphql-request");
@@ -5000,7 +5172,7 @@ var getActiveLockStateByNftId = async (nftId) => {
 // src/methods/createLongLocks/createLongLocks.ts
 async function createLongLocks({ walletAddress, nfts }, context) {
   const expireIn = 7 * 24 * 3600 * 1e3;
-  const tx = new import_transactions14.Transaction();
+  const tx = new import_transactions15.Transaction();
   for (const argNft of nfts) {
     const existingLock = await getActiveLockStateByNftId(argNft.id);
     if (existingLock) {
@@ -5063,10 +5235,10 @@ async function createLongLocks({ walletAddress, nfts }, context) {
 }
 
 // src/methods/createMultiBid/createMultiBid.ts
-var import_transactions16 = require("@mysten/sui/transactions");
+var import_transactions17 = require("@mysten/sui/transactions");
 
 // src/methods/updateMultiBid/updateMultiBid.ts
-var import_transactions15 = require("@mysten/sui/transactions");
+var import_transactions16 = require("@mysten/sui/transactions");
 async function updateMultiBid({
   multiBidId,
   name,
@@ -5075,7 +5247,7 @@ async function updateMultiBid({
   tx: existingTx,
   multiBidChainId
 }) {
-  const tx = typeof existingTx === "string" ? import_transactions15.Transaction.from(existingTx) : existingTx ?? new import_transactions15.Transaction();
+  const tx = typeof existingTx === "string" ? import_transactions16.Transaction.from(existingTx) : existingTx ?? new import_transactions16.Transaction();
   if (!multiBidChainId) {
     const { chain_id: chainId, cancelled_at } = (await gqlChainRequest({
       chain: "sui",
@@ -5111,7 +5283,7 @@ async function createMultiBid({
   amount,
   tx: existingTx
 }) {
-  const tx = existingTx ?? new import_transactions16.Transaction();
+  const tx = existingTx ?? new import_transactions17.Transaction();
   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)]
@@ -5129,10 +5301,10 @@ async function createMultiBid({
 }
 
 // src/methods/createShortLocks/createShortLocks.ts
-var import_transactions17 = require("@mysten/sui/transactions");
+var import_transactions18 = require("@mysten/sui/transactions");
 async function createShortLocks({ nfts }, context) {
   const expireIn = 7 * 24 * 3600 * 1e3;
-  const tx = new import_transactions17.Transaction();
+  const tx = new import_transactions18.Transaction();
   for (const argNft of nfts) {
     const premium = calculatePremium(BigInt(argNft.priceInMist));
     if (!argNft.type) {
@@ -5170,7 +5342,7 @@ async function createShortLocks({ nfts }, context) {
 }
 
 // src/methods/listNfts/listNfts.ts
-var import_transactions18 = require("@mysten/sui/transactions");
+var import_transactions19 = require("@mysten/sui/transactions");
 
 // src/methods/listNfts/addListTxs.ts
 async function addOriginByteListTx({
@@ -5181,17 +5353,20 @@ async function addOriginByteListTx({
   seller,
   listPrice,
   collectionId,
-  sellerKiosk
+  sellerKiosk,
+  sharedKioskState
 }) {
   const { orderbook } = sharedObjects;
   await assertNftInSharedKiosk({
     kioskId: sellerKiosk,
-    walletAddress: seller
+    walletAddress: seller,
+    sharedKioskState
   });
   const { kiosk, isNewKiosk } = await getOrCreateOBKiosk({
     tx,
     address: seller,
-    kioskToUseIfExists: sellerKiosk
+    kioskToUseIfExists: sellerKiosk,
+    sharedKioskState
   });
   if (isNewKiosk) {
     depositItemIntoOBKiosk({
@@ -5215,7 +5390,7 @@ async function addOriginByteListTx({
     typeArguments: [nftType, "0x2::sui::SUI"]
   });
   if (isNewKiosk) {
-    await shareOriginByteKiosk({ tx, kiosk });
+    shareOriginByteKiosk({ tx, kiosk });
   }
 }
 function addTradePortListTx({
@@ -5288,6 +5463,7 @@ async function addTradePortListTxHandler(txData) {
       kioskOwner: txData?.seller,
       kiosk: txData?.sellerKiosk,
       shouldAssertNftInSharedKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         const borrowedItem = await takeAndBorrowNftFromKiosk({
           tx: txData?.tx,
@@ -5310,6 +5486,7 @@ async function addTradePortListTxHandler(txData) {
       kioskOwner: txData?.seller,
       kiosk: txData?.sellerKiosk,
       shouldAssertNftInSharedKiosk: true,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         await addTradePortKioskListTx({
           ...txData,
@@ -5324,6 +5501,7 @@ async function addTradePortListTxHandler(txData) {
       kioskClient: txData?.kioskClient,
       kioskOwner: txData?.seller,
       kiosk: txData?.sellerKiosk,
+      sharedKioskState: txData?.sharedKioskState,
       async runCommands(kioskTx) {
         kioskTx.place({
           item: txData?.nftTokenId,
@@ -5384,15 +5562,21 @@ async function relistNft({
   tx,
   suiClient,
   kioskClient,
+  sharedKioskState,
   nft,
   listPrice,
   transferPolicies,
   walletAddress
 }) {
+  const firstListedOrExpiredListing = (nft?.listings).find((l) => l.listed || l.nonce);
+  if (!firstListedOrExpiredListing) {
+    throw new Error("No listing found for NFT");
+  }
   const txData = {
     tx,
     suiClient,
     kioskClient,
+    sharedKioskState,
     transferPolicies,
     nftTokenId: nft?.token_id,
     nftType: getNftType({
@@ -5400,13 +5584,13 @@ async function relistNft({
       collectionChainState: nft?.collection?.chain_state,
       nft
     }),
-    listingNonce: nft?.listings?.[0]?.nonce,
-    price: nft?.listings?.[0]?.price,
+    listingNonce: firstListedOrExpiredListing.nonce,
+    price: firstListedOrExpiredListing.price,
     sellerKiosk: nft?.chain_state?.kiosk_id,
     collectionId: nft?.collection_id,
     seller: walletAddress
   };
-  switch (nft?.listings?.[0]?.market_name) {
+  switch (firstListedOrExpiredListing.market_name) {
     case "tradeport":
       if ((!isOriginByteCollection(txData?.transferPolicies) || ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) && txData?.listingNonce && await isNonKioskListing({
         suiClient: txData?.suiClient,
@@ -5428,6 +5612,7 @@ async function relistNft({
           kioskOwner: txData?.seller,
           kiosk: txData?.sellerKiosk,
           shouldAssertNftInSharedKiosk: true,
+          sharedKioskState: txData?.sharedKioskState,
           async runCommands(kioskTx) {
             await addTradePortKioskUnlistTx({
               ...txData,
@@ -5484,7 +5669,10 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
     throw new Error("No nfts found");
   }
   const nftsForTracking = [];
-  const tx = new import_transactions18.Transaction();
+  const tx = new import_transactions19.Transaction();
+  const sharedKioskState = {
+    kioskTx: void 0
+  };
   for (const nft of res.nfts) {
     if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(nft?.token_id)) {
       throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
@@ -5502,6 +5690,7 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
         tx,
         suiClient: context.suiClient,
         kioskClient: context.kioskClient,
+        sharedKioskState,
         transferPolicies,
         nft,
         listPrice: nfts?.find((n) => n.id === nft?.id)?.listPriceInMist,
@@ -5512,6 +5701,7 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
         tx,
         suiClient: context.suiClient,
         kioskClient: context.kioskClient,
+        sharedKioskState,
         transferPolicies,
         seller: walletAddress,
         collectionId: nft?.collection_id,
@@ -5531,11 +5721,12 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
       marketRelistedFrom: nft?.listings?.[0]?.market_name
     });
   }
-  return import_transactions18.Transaction.from(tx);
+  sharedKioskState?.kioskTx?.finalize();
+  return import_transactions19.Transaction.from(tx);
 };
 
 // src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts
-var import_transactions19 = require("@mysten/sui/transactions");
+var import_transactions20 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchNftsByKioskId.ts
 var import_graphql_request19 = require("graphql-request");
@@ -5589,13 +5780,15 @@ async function addOriginByteTransferNftTx({
   nftType,
   recipientAddress,
   senderKiosk,
-  senderAddress
+  senderAddress,
+  sharedKioskState
 }) {
   await assertNftInSharedKiosk({
     kioskId: senderKiosk,
-    walletAddress: senderAddress
+    walletAddress: senderAddress,
+    sharedKioskState
   });
-  const recipientOBKiosk = await getOBKiosk(recipientAddress);
+  const recipientOBKiosk = await getOBKiosk({ wallet: recipientAddress, sharedKioskState });
   if (recipientOBKiosk) {
     tx.moveCall({
       target: "0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer",
@@ -5643,7 +5836,7 @@ async function addTradeportKioskTransferTx({
   });
 }
 async function addTradeportKioskDirectTransferTx(txData, nfts, suiClient) {
-  const { tx, recipientAddress, kioskClient, senderAddress } = txData;
+  const { tx, recipientAddress, kioskClient, sharedKioskState, senderAddress } = txData;
   if (nfts.length === 0) {
     return;
   }
@@ -5686,6 +5879,7 @@ async function addTradeportKioskDirectTransferTx(txData, nfts, suiClient) {
       kioskClient,
       kioskOwner: senderAddress,
       kiosk: nft?.chain_state?.kiosk_id,
+      sharedKioskState,
       async runCommands(kioskTx) {
         tx.moveCall({
           target: "0xd0ad5bf7ac7d372cdcfee5273d5e487dabad724040e089c626cba2a01127ccd6::kiosk_transfers::direct_transfer",
@@ -5734,7 +5928,7 @@ async function getTransferPolicyForDirectTransfer(suiClient, collectionChainStat
 
 // src/methods/migrateNftsFromUnsharedToSharedKiosks/migrateNftsFromUnsharedToSharedKiosks.ts
 async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }, context) {
-  const tx = new import_transactions19.Transaction();
+  const tx = new import_transactions20.Transaction();
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchKiosksByOwner,
@@ -5825,7 +6019,9 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
   transferPolicies.forEach((tp) => {
     mappedTrasferPolicies[tp?.[0]?.type] = tp;
   });
-  let globalKioskTx;
+  const sharedKioskState = {
+    kioskTx: void 0
+  };
   for (const unsharedNativeKiosk of unsharedNativeKiosks) {
     if (currentMigrationCount >= max) {
       continue;
@@ -5851,6 +6047,7 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
         kioskOwner: walletAddress,
         kiosk: unsharedNativeKiosk,
         shouldAllowNftUnsharedKiosk: true,
+        sharedKioskState,
         async runCommands(kioskTx) {
           await addTradeportKioskTransferTx({
             tx,
@@ -5873,11 +6070,9 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
         kioskOwner: walletAddress,
         kiosk: unsharedNativeKiosk,
         kioskStrategy: "exclude",
-        kioskTx: globalKioskTx,
-        shouldSkipFinalize: true,
         shouldConvertToPersonalKiosk: true,
+        sharedKioskState,
         async runCommands(kioskTx) {
-          existingKioskTx = kioskTx;
           await addClaimTransferredNftWithPurchaseCapTx({
             tx,
             kioskTx,
@@ -5894,15 +6089,14 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 50 }
           });
         }
       });
-      globalKioskTx = existingKioskTx;
     }
   }
-  globalKioskTx?.finalize();
-  return import_transactions19.Transaction.from(tx);
+  sharedKioskState?.kioskTx?.finalize();
+  return import_transactions20.Transaction.from(tx);
 }
 
 // src/methods/placeCollectionBids/placeCollectionBids.ts
-var import_transactions20 = require("@mysten/sui/transactions");
+var import_transactions21 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchCollectionsById.ts
 var import_graphql_request20 = require("graphql-request");
@@ -5958,12 +6152,12 @@ async function addTradePortPlaceNftBidTxHandler(txData) {
     bcsHex,
     expireAt
   } = txData;
-  let bcs3;
+  let bcs4;
   if (nftTokenId && isDynamicCollection(collectionId)) {
     if (!bcsHex) {
       throw new Error(`No BCS found for token ${nftTokenId}`);
     }
-    bcs3 = (0, import_utils10.fromHex)(bcsHex);
+    bcs4 = (0, import_utils10.fromHex)(bcsHex);
   }
   let multiBidChainId;
   if (existingMultiBidChainId) {
@@ -6009,7 +6203,7 @@ async function addTradePortPlaceNftBidTxHandler(txData) {
         arguments: [multiBidChainId]
       }) : void 0,
       tx.pure.option("id", nftTokenId ? (0, import_utils10.normalizeSuiObjectId)(nftTokenId) : void 0),
-      tx.pure.option("vector<u8>", bcs3 ? [...bcs3] : void 0),
+      tx.pure.option("vector<u8>", bcs4 ? [...bcs4] : void 0),
       tx.pure.option("u64", expireAt?.getTime()),
       tx.pure.u64(price),
       ...transferPolicy ? [tx.object(transferPolicy.id)] : [],
@@ -6106,7 +6300,7 @@ var placeCollectionBids = async ({ collections, walletAddress, multiBidId, multi
     throw new Error("No collection found");
   }
   const collectionsForTracking = [];
-  const tx = existingTx ? import_transactions20.Transaction.from(existingTx) : new import_transactions20.Transaction();
+  const tx = existingTx ? import_transactions21.Transaction.from(existingTx) : new import_transactions21.Transaction();
   for (const collection of res.collections) {
     const nftType = getNftType({
       collectionId: collection?.id,
@@ -6128,10 +6322,8 @@ var placeCollectionBids = async ({ collections, walletAddress, multiBidId, multi
       expireAt: collections?.find((c) => c.id === collection?.id)?.expireAt
     };
     const numOfBids = collections?.find((c) => c.id === collection?.id)?.numOfBids;
-    console.log("txData", txData);
     if (isOriginByteCollection(txData?.transferPolicies) && !ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) {
       const sharedObjects = await getSharedObjects(txData?.nftType);
-      console.log("sharedObjects", sharedObjects);
       const { kiosk: bidderKiosk, isNewKiosk: isNewBidderKiosk } = await getOrCreateOBKiosk({
         tx,
         address: txData.bidder
@@ -6140,7 +6332,7 @@ var placeCollectionBids = async ({ collections, walletAddress, multiBidId, multi
         await addOriginByteCollectionBidTx({ ...txData, bidderKiosk, sharedObjects });
       }
       if (isNewBidderKiosk) {
-        await shareOriginByteKiosk({ tx, kiosk: bidderKiosk });
+        shareOriginByteKiosk({ tx, kiosk: bidderKiosk });
       }
     } else {
       for (let i = 0; i < numOfBids; i++) {
@@ -6154,13 +6346,13 @@ var placeCollectionBids = async ({ collections, walletAddress, multiBidId, multi
       bidder: walletAddress
     });
   }
-  return import_transactions20.Transaction.from(tx);
+  return import_transactions21.Transaction.from(tx);
 };
 
 // src/methods/placeNftBids/placeNftBids.ts
-var import_transactions21 = require("@mysten/sui/transactions");
+var import_transactions22 = require("@mysten/sui/transactions");
 var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx: existingTx }, context) => {
-  const tx = existingTx ? import_transactions21.Transaction.from(existingTx) : new import_transactions21.Transaction();
+  const tx = existingTx ? import_transactions22.Transaction.from(existingTx) : new import_transactions22.Transaction();
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchNftsById,
@@ -6203,11 +6395,11 @@ var placeNftBids = async ({ bids, walletAddress, multiBidId, multiBidChainId, tx
       bidder: walletAddress
     });
   }
-  return import_transactions21.Transaction.from(tx);
+  return import_transactions22.Transaction.from(tx);
 };
 
 // src/methods/removeCollectionBids/removeCollectionBids.ts
-var import_transactions22 = require("@mysten/sui/transactions");
+var import_transactions23 = require("@mysten/sui/transactions");
 
 // src/methods/removeCollectionBids/addRemoveCollectionBidsTxs.ts
 var import_utils12 = require("@mysten/sui/utils");
@@ -6397,7 +6589,7 @@ var removeCollectionBids = async ({ bidIds, tx: existingTx }, context) => {
     throw new Error("No bids found");
   }
   const bidsForTracking = [];
-  const tx = existingTx ? import_transactions22.Transaction.from(existingTx) : new import_transactions22.Transaction();
+  const tx = existingTx ? import_transactions23.Transaction.from(existingTx) : new import_transactions23.Transaction();
   for (const bid of res.bids) {
     if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(bid?.nft?.token_id)) {
       throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
@@ -6445,11 +6637,11 @@ var removeCollectionBids = async ({ bidIds, tx: existingTx }, context) => {
       bidder: bid?.bidder
     });
   }
-  return import_transactions22.Transaction.from(tx);
+  return import_transactions23.Transaction.from(tx);
 };
 
 // src/methods/removeNftBids/removeNftBids.ts
-var import_transactions23 = require("@mysten/sui/transactions");
+var import_transactions24 = require("@mysten/sui/transactions");
 var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -6460,7 +6652,7 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
     throw new Error("No bids found");
   }
   const bidsForTracking = [];
-  const tx = existingTx ? import_transactions23.Transaction.from(existingTx) : new import_transactions23.Transaction();
+  const tx = existingTx ? import_transactions24.Transaction.from(existingTx) : new import_transactions24.Transaction();
   for (const bid of res.bids) {
     if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(bid?.nft?.token_id)) {
       throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
@@ -6505,11 +6697,11 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
       bidder: bid?.bidder
     });
   }
-  return import_transactions23.Transaction.from(tx);
+  return import_transactions24.Transaction.from(tx);
 };
 
 // src/methods/transferNfts/transferNfts.ts
-var import_transactions24 = require("@mysten/sui/transactions");
+var import_transactions25 = require("@mysten/sui/transactions");
 var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context) => {
   if (addLeadingZerosAfter0x(recipientAddress) === addLeadingZerosAfter0x(walletAddress)) {
     throw new Error("Cannot transfer to self");
@@ -6527,7 +6719,10 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
   }
   const nftsForTracking = [];
   const nftsToTransferDirectly = [];
-  const tx = new import_transactions24.Transaction();
+  const tx = new import_transactions25.Transaction();
+  const sharedKioskState = {
+    kioskTx: void 0
+  };
   for (const nft of res.nfts) {
     if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(nft?.token_id)) {
       throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
@@ -6545,6 +6740,7 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
       tx,
       suiClient: context.suiClient,
       kioskClient: context.kioskClient,
+      sharedKioskState,
       nftType,
       nftTokenId: nft?.token_id,
       senderKiosk: nft?.chain_state?.kiosk_id,
@@ -6571,6 +6767,7 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
         kioskOwner: txData?.senderAddress,
         kiosk: txData?.senderKiosk,
         shouldAssertNftInSharedKiosk: true,
+        sharedKioskState: txData?.sharedKioskState,
         async runCommands(kioskTx) {
           const borrowedItem = await takeAndBorrowNftFromKiosk({
             tx: txData?.tx,
@@ -6599,6 +6796,7 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
         kioskOwner: txData?.senderAddress,
         kiosk: txData?.senderKiosk,
         shouldAssertNftInSharedKiosk: true,
+        sharedKioskState: txData?.sharedKioskState,
         async runCommands(kioskTx) {
           await addTradeportKioskTransferTx({ ...txData, kioskTx });
         }
@@ -6611,15 +6809,22 @@ var transferNfts = async ({ nftIds, recipientAddress, walletAddress }, context)
     });
   }
   await addTradeportKioskDirectTransferTx(
-    { tx, kioskClient: context.kioskClient, senderAddress: walletAddress, recipientAddress },
+    {
+      tx,
+      kioskClient: context.kioskClient,
+      sharedKioskState,
+      senderAddress: walletAddress,
+      recipientAddress
+    },
     nftsToTransferDirectly,
     context.suiClient
   );
-  return import_transactions24.Transaction.from(tx);
+  sharedKioskState?.kioskTx?.finalize();
+  return import_transactions25.Transaction.from(tx);
 };
 
 // src/methods/unlistListings/unlistListings.ts
-var import_transactions25 = require("@mysten/sui/transactions");
+var import_transactions26 = require("@mysten/sui/transactions");
 var import_utils13 = require("@mysten/sui/utils");
 var unlistListings = async ({ listingIds, walletAddress }, context) => {
   const res = await gqlChainRequest({
@@ -6631,7 +6836,10 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
     throw new Error("No listings found");
   }
   const listingsForTracking = [];
-  const tx = new import_transactions25.Transaction();
+  const tx = new import_transactions26.Transaction();
+  const sharedKioskState = {
+    kioskTx: void 0
+  };
   for (const listing of res.listings) {
     if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(listing?.nft?.token_id)) {
       throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
@@ -6649,6 +6857,7 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
       tx,
       suiClient: context.suiClient,
       kioskClient: context.kioskClient,
+      sharedKioskState,
       transferPolicies,
       nftTokenId: listing.nft?.token_id,
       nftType,
@@ -6695,12 +6904,13 @@ var unlistListings = async ({ listingIds, walletAddress }, context) => {
       marketName: listing?.market_name
     });
   }
-  return import_transactions25.Transaction.from(tx);
+  sharedKioskState?.kioskTx?.finalize();
+  return import_transactions26.Transaction.from(tx);
 };
 
 // src/methods/withdrawProfitsFromKiosks/withdrawProfitsFromKiosks.ts
 var import_kiosk5 = require("@mysten/kiosk");
-var import_transactions26 = require("@mysten/sui/transactions");
+var import_transactions27 = require("@mysten/sui/transactions");
 async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   const res = await gqlChainRequest({
     chain: "sui",
@@ -6717,7 +6927,7 @@ async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   if (kiosksWithProfit.length === 0) {
     throw new Error(`No kiosks with profit to withdraw found for ${walletAddress}`);
   }
-  const tx = new import_transactions26.Transaction();
+  const tx = new import_transactions27.Transaction();
   try {
     for (const kiosk of kiosksWithProfit) {
       let kioskTx;
@@ -6763,7 +6973,7 @@ async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   } catch (err) {
     console.log("err", err);
   }
-  return import_transactions26.Transaction.from(tx);
+  return import_transactions27.Transaction.from(tx);
 }
 
 // src/SuiTradingClient.ts