@tradeport/sui-trading-sdk 0.1.92 → 0.1.93

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @tradeport/sui-trading-sdk
 
+## 0.1.93
+
+### Patch Changes
+
+- c88bdb6: Fixes for accept collection bids
+
 ## 0.1.92
 
 ### Patch Changes

package/dist/index.js

@@ -521,7 +521,8 @@ var kioskTxWrapper = async ({
   shouldConvertToPersonalKiosk,
   shouldAssertNftInSharedKiosk,
   shouldUseNftUnsharedKiosk,
-  kioskStrategy
+  kioskStrategy,
+  failIfNoKiosk
 }) => {
   if (kioskTx) {
     await runCommands(kioskTx);
@@ -550,6 +551,8 @@ var kioskTxWrapper = async ({
     }
     if (filteredKiosks.length > 0) {
       kiosks = filteredKiosks;
+    } else if (failIfNoKiosk ?? false) {
+      throw new Error(`Kiosk ${kiosk} not found for account ${kioskOwner}`);
     }
   }
   const personalKiosk = kiosks.find((k) => k.is_personal);
@@ -706,18 +709,16 @@ var shareOriginByteKiosk = async ({ tx, kiosk }) => {
 };
 
 // src/helpers/rpc/getObjectType.ts
+var import_utils = require("@mysten/sui/utils");
 var getObjectType = async ({
   suiClient,
   objectId
 }) => {
-  try {
+  if ((0, import_utils.isValidSuiObjectId)(objectId)) {
     const res = await suiClient.getObject({ id: objectId, options: { showType: true } });
-    console.log("res", res);
-    return res?.data?.type;
-  } catch (err) {
-    console.log("err", err);
-    return "";
+    return res.data.type;
   }
+  return "";
 };
 
 // src/helpers/kiosk/lockNftInsideKioskIfNotLocked.ts
@@ -725,36 +726,67 @@ var lockNftInsideKioskIfNotLocked = async ({
   tx,
   kioskClient,
   kioskTx,
-  sellerKiosk,
   nftTokenId,
   nftType,
   transferPolicyId
 }) => {
-  try {
-    let isLocked = false;
-    if (sellerKiosk) {
-      const res = await kioskClient.getKiosk({ id: sellerKiosk });
-      isLocked = res?.items?.find((i) => i.objectId === nftTokenId)?.isLocked;
-    }
-    if (isLocked) return;
-    const item = kioskTx.take({
-      itemId: nftTokenId,
-      itemType: nftType
+  if (lockNftInsideKioskIfKioskCreatedInThisTx({ tx, kioskTx, nftTokenId, nftType, transferPolicyId })) {
+    return;
+  }
+  const kioskId = "value" in kioskTx.kiosk ? kioskTx.kiosk.value : "index" in kioskTx.kiosk ? tx.blockData.inputs[kioskTx.kiosk.index].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 }
     });
-    tx.moveCall({
-      target: "0x2::kiosk::lock",
-      typeArguments: [nftType],
-      arguments: [
-        tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
-        tx.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
-        tx.object(transferPolicyId),
-        tx.object(item)
-      ]
+    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
     });
-  } catch (e) {
-    console.log("error attempting to lock nft inside kiosk if not locked", e);
   }
 };
+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");
@@ -1044,11 +1076,18 @@ async function addTradeportKioskAcceptNftBidTx({
   royaltyRulePackageId,
   royaltyRuleModule,
   bidAmount,
-  sellerKiosk,
   shouldSplitRoyaltyFromUserGasCoins,
   beforeResolveKioskTransferRequest
 }) {
   const transferPolicyId = (await getKioskTransferPolicies(nftType))?.at(0)?.id;
+  await lockNftInsideKioskIfNotLocked({
+    tx,
+    kioskClient,
+    kioskTx,
+    nftTokenId,
+    nftType,
+    transferPolicyId
+  });
   if (beforeResolveKioskTransferRequest) {
     const [feeCoin, transferRequest] = tx.moveCall({
       target: "0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::accept_bid_with_price_lock",
@@ -1074,15 +1113,6 @@ async function addTradeportKioskAcceptNftBidTx({
     });
     tx.transferObjects([tx.object(feeCoin)], tx.pure.address(addLeadingZerosAfter0x(seller)));
   } else {
-    await lockNftInsideKioskIfNotLocked({
-      tx,
-      kioskClient,
-      kioskTx,
-      sellerKiosk,
-      nftTokenId,
-      nftType,
-      transferPolicyId
-    });
     const [feeCoin, transferRequest] = tx.moveCall({
       target: "0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::accept_bid_with_purchase_cap",
       arguments: [
@@ -1209,6 +1239,7 @@ async function addTradePortAcceptNftBidTxHandler(txData) {
         kiosk: txData?.sellerKiosk,
         shouldConvertToPersonalKiosk: Boolean(await hasPersonalKioskRule(txData?.nftType)),
         shouldAssertNftInSharedKiosk: true,
+        failIfNoKiosk: true,
         async runCommands(kioskTx) {
           await addTradeportKioskAcceptNftBidTx({
             ...txData,
@@ -1640,59 +1671,30 @@ async function addTradePortAcceptCollectionBidTxHandler(txData) {
     });
   }
   if (isTradePortKioskBid(bidType)) {
-    if (txData?.sellerKiosk) {
-      const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
-      const royaltyRulePackageId = await getRulePackageId({
-        nftType: txData?.nftType,
-        ruleType: "royalty_rule",
-        kioskClient: txData?.kioskClient
-      });
-      return kioskTxWrapper({
-        tx: txData?.tx,
-        kioskClient: txData?.kioskClient,
-        kioskTx: txData?.kioskTx,
-        kioskOwner: txData?.itemOwner,
-        kiosk: txData?.sellerKiosk,
-        shouldConvertToPersonalKiosk: Boolean(await hasPersonalKioskRule(txData?.nftType)),
-        shouldAssertNftInSharedKiosk: true,
-        async runCommands(kioskTx) {
-          await addTradeportKioskAcceptCollectionBidTx({
-            ...txData,
-            kioskTx,
-            royaltyRulePackageId,
-            royaltyRuleModule
-          });
-        }
-      });
-    }
-    if (await hasTransferPolicyRules(txData?.nftType) && !txData?.sellerKiosk) {
-      const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
-      const royaltyRulePackageId = await getRulePackageId({
-        nftType: txData?.nftType,
-        ruleType: "royalty_rule",
-        kioskClient: txData?.kioskClient
-      });
-      return kioskTxWrapper({
-        tx: txData?.tx,
-        kioskClient: txData?.kioskClient,
-        kioskTx: txData?.kioskTx,
-        kioskOwner: txData?.seller,
-        kiosk: txData?.sellerKiosk,
-        shouldConvertToPersonalKiosk: Boolean(await hasPersonalKioskRule(txData?.nftType)),
-        async runCommands(kioskTx) {
-          kioskTx.place({
-            item: txData?.nftTokenId,
-            itemType: txData?.nftType
-          });
-          await addTradeportKioskAcceptCollectionBidTx({
-            ...txData,
-            kioskTx,
-            royaltyRulePackageId,
-            royaltyRuleModule
-          });
-        }
-      });
-    }
+    const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
+    const royaltyRulePackageId = await getRulePackageId({
+      nftType: txData?.nftType,
+      ruleType: "royalty_rule",
+      kioskClient: txData?.kioskClient
+    });
+    return kioskTxWrapper({
+      tx: txData?.tx,
+      kioskClient: txData?.kioskClient,
+      kioskTx: txData?.kioskTx,
+      kioskOwner: txData?.itemOwner,
+      kiosk: txData?.sellerKiosk,
+      shouldConvertToPersonalKiosk: Boolean(await hasPersonalKioskRule(txData?.nftType)),
+      shouldAssertNftInSharedKiosk: true,
+      failIfNoKiosk: Boolean(txData?.sellerKiosk),
+      async runCommands(kioskTx) {
+        await addTradeportKioskAcceptCollectionBidTx({
+          ...txData,
+          kioskTx,
+          royaltyRulePackageId,
+          royaltyRuleModule
+        });
+      }
+    });
   }
   addTradeportAcceptCollectionBidTx(txData);
 }
@@ -1955,7 +1957,7 @@ var acceptNftBids = async ({ bidIds, tx: existingTx, kioskTx, beforeResolveKiosk
 var import_transactions5 = require("@mysten/sui/transactions");
 
 // src/methods/buyLocks/buyLocks.ts
-var import_utils = require("@mysten/sui.js/utils");
+var import_utils2 = require("@mysten/sui.js/utils");
 var import_transactions3 = require("@mysten/sui/transactions");
 
 // src/helpers/calculatePremium.ts
@@ -2098,7 +2100,7 @@ async function buyLocks({ lockIds, transaction }, context) {
       typeArguments: [lock.nft_type],
       arguments: [
         tx.object(TRADEPORT_PRICE_LOCK_STORE),
-        tx.object(import_utils.SUI_CLOCK_OBJECT_ID),
+        tx.object(import_utils2.SUI_CLOCK_OBJECT_ID),
         tx.pure.id(lock.lock_id),
         tx.pure.u64(lock.maker_price),
         tx.pure.u64(marketplaceFee),
@@ -2112,7 +2114,7 @@ async function buyLocks({ lockIds, transaction }, context) {
 }
 
 // src/methods/exerciseLongLocks/exerciseLongLocks.ts
-var import_utils2 = require("@mysten/sui.js/utils");
+var import_utils3 = require("@mysten/sui.js/utils");
 var import_transactions4 = require("@mysten/sui/transactions");
 async function exerciseLongLocks({ walletAddress, transaction, locks }, context) {
   const tx = transaction ?? new import_transactions4.Transaction();
@@ -2170,7 +2172,7 @@ async function exerciseLongLocks({ walletAddress, transaction, locks }, context)
           typeArguments: [lock.nft_type],
           arguments: [
             tx.object(TRADEPORT_PRICE_LOCK_STORE),
-            tx.object(import_utils2.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils3.SUI_CLOCK_OBJECT_ID),
             tx.pure.id(lock.lock_id),
             tx.object(lock.chain_state.makerKioskId),
             tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
@@ -2271,7 +2273,7 @@ async function buyAndExerciseLongLocks({ walletAddress, locks, tx: existingTx },
 var import_transactions8 = require("@mysten/sui/transactions");
 
 // src/methods/exerciseShortLocks/exerciseShortLocks.ts
-var import_utils3 = require("@mysten/sui.js/utils");
+var import_utils4 = require("@mysten/sui.js/utils");
 var import_transactions7 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchListingsById.ts
@@ -2969,7 +2971,7 @@ async function exerciseShortLocks({ walletAddress, transaction, locks }, context
           typeArguments: [lock.nft_type],
           arguments: [
             tx.object(TRADEPORT_PRICE_LOCK_STORE),
-            tx.object(import_utils3.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils4.SUI_CLOCK_OBJECT_ID),
             tx.pure.id(lock.lock_id)
           ]
         });
@@ -3048,7 +3050,7 @@ async function buyAndExerciseShortLocks({ walletAddress, locks, tx: existingTx }
 }
 
 // src/methods/cancelLocks/cancelLocks.ts
-var import_utils4 = require("@mysten/sui.js/utils");
+var import_utils5 = require("@mysten/sui.js/utils");
 var import_transactions9 = require("@mysten/sui/transactions");
 async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, context) {
   const tx = existingTx ?? new import_transactions9.Transaction();
@@ -3071,7 +3073,7 @@ async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, 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.object(kioskTx.kiosk.value ?? kioskTx.kiosk)
           ]
@@ -5374,49 +5376,44 @@ var SuiTradingClient = class {
       }
     });
     const allBidsWithSameHighestPrice = allBidsWithSameHighestPriceRes?.bids;
-    for (let i = 0; i < allBidsWithSameHighestPrice?.length; i++) {
-      try {
-        const tx = await acceptCollectionBid(
-          {
-            bid: allBidsWithSameHighestPrice?.[i],
-            nftId,
-            walletAddress
-          },
-          context
-        );
-        tx.setSenderIfNotSet(addLeadingZerosAfter0x(walletAddress));
-        const rawTransaction = await tx.build({ client: this.suiClient });
-        await this.suiClient.dryRunTransactionBlock({
-          transactionBlock: rawTransaction
-        });
+    for (let i = 0; i < (allBidsWithSameHighestPrice?.length ?? 0); i++) {
+      const tx = await acceptCollectionBid(
+        {
+          bid: allBidsWithSameHighestPrice?.[i],
+          nftId,
+          walletAddress
+        },
+        context
+      );
+      let result = await this.suiClient.devInspectTransactionBlock({
+        transactionBlock: tx,
+        sender: addLeadingZerosAfter0x(walletAddress)
+      });
+      if (result.effects.status.status === "success") {
         return tx;
-      } catch (err) {
-        if (i === allBidsWithSameHighestPrice.length - 1) {
-          for (let j = 0; j < allBidsWithSameHighestPrice?.length; j++) {
-            try {
-              const tx = await acceptCollectionBid(
-                {
-                  bid: allBidsWithSameHighestPrice?.[j],
-                  nftId,
-                  walletAddress,
-                  shouldSplitRoyaltyFromUserGasCoins: true
-                },
-                context
-              );
-              tx.setSenderIfNotSet(addLeadingZerosAfter0x(walletAddress));
-              const rawTransaction = await tx.build({ client: this.suiClient });
-              await this.suiClient.dryRunTransactionBlock({
-                transactionBlock: rawTransaction
-              });
-              return tx;
-            } catch (err2) {
-              if (j === allBidsWithSameHighestPrice.length - 1) {
-                throw err2;
-              }
-            }
+      }
+      if (i === allBidsWithSameHighestPrice.length - 1) {
+        for (let j = 0; j < allBidsWithSameHighestPrice?.length; j++) {
+          const tx2 = await acceptCollectionBid(
+            {
+              bid: allBidsWithSameHighestPrice?.[j],
+              nftId,
+              walletAddress,
+              shouldSplitRoyaltyFromUserGasCoins: true
+            },
+            context
+          );
+          result = await this.suiClient.devInspectTransactionBlock({
+            transactionBlock: tx2,
+            sender: addLeadingZerosAfter0x(walletAddress)
+          });
+          if (result?.effects.status.status === "success") {
+            return tx2;
           }
-          throw err;
         }
+        throw new Error(
+          `Failed to validate accept bid transaction: ${result?.error ?? result?.effects?.status?.error ?? "Unknown error"}`
+        );
       }
     }
   }