@scallop-io/sui-scallop-sdk 1.3.2-alpha.3 → 1.3.2

package/dist/constants/queryKeys.d.ts

@@ -40,10 +40,7 @@ export declare const queryKeys: {
         })[];
         getDynamicFieldObject: (input?: Partial<GetDynamicFieldObjectParams>) => (string | {
             parentId: string | undefined;
-            name: {
-                type: string | undefined;
-                value: unknown;
-            };
+            name: string;
         })[];
         getTotalVeScaTreasuryAmount: (refreshArgs?: any[], vescaAmountArgs?: (string | SuiObjectData)[]) => (string | {
             refreshArgs: string;

package/dist/index.js

@@ -423,10 +423,7 @@ var queryKeys = {
       "getDynamicFieldObject",
       {
         parentId: input?.parentId,
-        name: {
-          type: input?.name?.type,
-          value: input?.name?.value
-        }
+        name: JSON.stringify(input?.name ?? void 0)
       }
     ],
     getTotalVeScaTreasuryAmount: (refreshArgs, vescaAmountArgs) => [
@@ -2394,86 +2391,6 @@ var getSupplyLimit = async (utils, poolName) => {
   return parsedData.data.fields.value;
 };
 
-// src/queries/isolatedAsset.ts
-var import_zod2 = require("zod");
-var isolatedAssetZod = import_zod2.z.object({
-  dataType: import_zod2.z.string(),
-  type: import_zod2.z.string(),
-  hasPublicTransfer: import_zod2.z.boolean(),
-  fields: import_zod2.z.object({
-    id: import_zod2.z.object({
-      id: import_zod2.z.string()
-    }),
-    name: import_zod2.z.object({
-      type: import_zod2.z.string()
-    }),
-    value: import_zod2.z.boolean()
-  })
-});
-var ISOLATED_ASSET_KEY = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::IsolatedAssetKey";
-var getIsolatedAssets = async (address) => {
-  try {
-    const marketObject = address.get("core.market");
-    const isolatedAssets = [];
-    if (!marketObject)
-      return isolatedAssets;
-    let hasNextPage = false;
-    let nextCursor = null;
-    const isIsolatedDynamicField = (dynamicField) => {
-      return dynamicField.name.type === ISOLATED_ASSET_KEY;
-    };
-    do {
-      const response = await address.cache.queryGetDynamicFields({
-        parentId: marketObject,
-        cursor: nextCursor,
-        limit: 10
-      });
-      if (!response)
-        break;
-      const isolatedAssetCoinTypes = response.data.filter(isIsolatedDynamicField).map(({ name }) => `0x${name.value.type.name}`);
-      isolatedAssets.push(...isolatedAssetCoinTypes);
-      if (response && response.hasNextPage && response.nextCursor) {
-        hasNextPage = true;
-        nextCursor = response.nextCursor;
-      } else {
-        hasNextPage = false;
-      }
-    } while (hasNextPage);
-    return isolatedAssets;
-  } catch (e) {
-    console.error(e);
-    return [];
-  }
-};
-var isIsolatedAsset = async (utils, coinName) => {
-  try {
-    const marketObject = utils.address.get("core.market");
-    const cachedData = utils.address.cache.queryClient.getQueryData([
-      "getDynamicFields",
-      marketObject
-    ]);
-    if (cachedData) {
-      const coinType2 = utils.parseCoinType(coinName);
-      return cachedData.includes(coinType2);
-    }
-    const coinType = utils.parseCoinType(coinName).slice(2);
-    const object = await utils.cache.queryGetDynamicFieldObject({
-      parentId: marketObject,
-      name: {
-        type: ISOLATED_ASSET_KEY,
-        value: coinType
-      }
-    });
-    const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
-    if (!parsedData.success)
-      return false;
-    return parsedData.data.fields.value;
-  } catch (e) {
-    console.error(e);
-    return false;
-  }
-};
-
 // src/queries/coreQuery.ts
 var queryMarket = async (query, indexer = false) => {
   const coinPrices = await query.utils.getCoinPrices();
@@ -2503,7 +2420,7 @@ var queryMarket = async (query, indexer = false) => {
   const queryTarget = `${packageId}::market_query::market_data`;
   const args = [marketId];
   const queryResult = await query.cache.queryInspectTxn({ queryTarget, args });
-  const marketData = queryResult?.events[0].parsedJson;
+  const marketData = queryResult?.events[0]?.parsedJson;
   for (const pool of marketData?.pools ?? []) {
     const coinType = (0, import_utils3.normalizeStructTag)(pool.type.name);
     const poolCoinName = query.utils.parseCoinNameFromType(coinType);
@@ -2558,7 +2475,8 @@ var queryMarket = async (query, indexer = false) => {
       borrowFee: parsedMarketPoolData.borrowFee,
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
       minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
-      isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
+      // isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
+      isIsolated: false,
       maxSupplyCoin,
       ...calculatedMarketPoolData
     };
@@ -2786,7 +2704,8 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
       minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
       maxSupplyCoin,
-      isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
+      // isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
+      isIsolated: false,
       ...calculatedMarketPoolData
     };
   }
@@ -3145,6 +3064,9 @@ var getSpools = async (query, stakeMarketCoinNames = [...SUPPORT_SPOOLS], indexe
 var getSpool = async (query, marketCoinName, indexer = false, marketPool, coinPrices) => {
   const coinName = query.utils.parseCoinName(marketCoinName);
   marketPool = marketPool || await query.getMarketPool(coinName, indexer);
+  if (!marketPool) {
+    throw new Error("Fail to fetch marketPool");
+  }
   const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
   const rewardPoolId = query.address.get(
     `spool.pools.${marketCoinName}.rewardPoolId`
@@ -3154,10 +3076,10 @@ var getSpool = async (query, marketCoinName, indexer = false, marketPool, coinPr
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);
     const coinName2 = query.utils.parseCoinName(marketCoinName);
-    const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
+    const rewardCoinName2 = query.utils.getSpoolRewardCoinName(marketCoinName);
     spoolIndexer.coinPrice = coinPrices?.[coinName2] || spoolIndexer.coinPrice;
     spoolIndexer.marketCoinPrice = (coinPrices?.[coinName2] ?? 0) * (marketPool ? marketPool.conversionRate : 0) || spoolIndexer.marketCoinPrice;
-    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName] || spoolIndexer.rewardCoinPrice;
+    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName2] || spoolIndexer.rewardCoinPrice;
     return spoolIndexer;
   }
   const spoolObjectResponse = await query.cache.queryGetObjects(
@@ -3166,70 +3088,71 @@ var getSpool = async (query, marketCoinName, indexer = false, marketPool, coinPr
       showContent: true
     }
   );
-  if (marketPool && spoolObjectResponse[0] && spoolObjectResponse[1]) {
-    const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
-    coinPrices = coinPrices || await query.utils.getCoinPrices([coinName, rewardCoinName]);
-    const spoolObject = spoolObjectResponse[0];
-    const rewardPoolObject = spoolObjectResponse[1];
-    if (spoolObject.content && "fields" in spoolObject.content) {
-      const spoolFields = spoolObject.content.fields;
-      const parsedSpoolData = parseOriginSpoolData({
-        stakeType: spoolFields.stake_type,
-        maxDistributedPoint: spoolFields.max_distributed_point,
-        distributedPoint: spoolFields.distributed_point,
-        distributedPointPerPeriod: spoolFields.distributed_point_per_period,
-        pointDistributionTime: spoolFields.point_distribution_time,
-        maxStake: spoolFields.max_stakes,
-        stakes: spoolFields.stakes,
-        index: spoolFields.index,
-        createdAt: spoolFields.created_at,
-        lastUpdate: spoolFields.last_update
+  if (!(spoolObjectResponse[0] && spoolObjectResponse[1])) {
+    throw new Error("Fail to fetch spoolObjectResponse!");
+  }
+  const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
+  coinPrices = coinPrices || await query.utils.getCoinPrices([coinName, rewardCoinName]);
+  const spoolObject = spoolObjectResponse[0];
+  const rewardPoolObject = spoolObjectResponse[1];
+  if (spoolObject.content && "fields" in spoolObject.content) {
+    const spoolFields = spoolObject.content.fields;
+    const parsedSpoolData = parseOriginSpoolData({
+      stakeType: spoolFields.stake_type,
+      maxDistributedPoint: spoolFields.max_distributed_point,
+      distributedPoint: spoolFields.distributed_point,
+      distributedPointPerPeriod: spoolFields.distributed_point_per_period,
+      pointDistributionTime: spoolFields.point_distribution_time,
+      maxStake: spoolFields.max_stakes,
+      stakes: spoolFields.stakes,
+      index: spoolFields.index,
+      createdAt: spoolFields.created_at,
+      lastUpdate: spoolFields.last_update
+    });
+    const marketCoinPrice = (coinPrices?.[coinName] ?? 0) * marketPool.conversionRate;
+    const marketCoinDecimal = query.utils.getCoinDecimal(marketCoinName);
+    const calculatedSpoolData = calculateSpoolData(
+      parsedSpoolData,
+      marketCoinPrice,
+      marketCoinDecimal
+    );
+    if (rewardPoolObject.content && "fields" in rewardPoolObject.content) {
+      const rewardPoolFields = rewardPoolObject.content.fields;
+      const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
+        claimed_rewards: rewardPoolFields.claimed_rewards,
+        exchange_rate_numerator: rewardPoolFields.exchange_rate_numerator,
+        exchange_rate_denominator: rewardPoolFields.exchange_rate_denominator,
+        rewards: rewardPoolFields.rewards,
+        spool_id: rewardPoolFields.spool_id
       });
-      const marketCoinPrice = (coinPrices?.[coinName] ?? 0) * marketPool.conversionRate;
-      const marketCoinDecimal = query.utils.getCoinDecimal(marketCoinName);
-      const calculatedSpoolData = calculateSpoolData(
+      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+      const calculatedRewardPoolData = calculateSpoolRewardPoolData(
         parsedSpoolData,
+        parsedSpoolRewardPoolData,
+        calculatedSpoolData,
+        rewardCoinPrice,
+        rewardCoinDecimal
+      );
+      spool = {
+        marketCoinName,
+        symbol: query.utils.parseSymbol(marketCoinName),
+        coinType: query.utils.parseCoinType(coinName),
+        marketCoinType: query.utils.parseMarketCoinType(coinName),
+        rewardCoinType: isMarketCoin(rewardCoinName) ? query.utils.parseMarketCoinType(rewardCoinName) : query.utils.parseCoinType(rewardCoinName),
+        coinDecimal: query.utils.getCoinDecimal(coinName),
+        rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
+        coinPrice: coinPrices?.[coinName] ?? 0,
         marketCoinPrice,
-        marketCoinDecimal
-      );
-      if (rewardPoolObject.content && "fields" in rewardPoolObject.content) {
-        const rewardPoolFields = rewardPoolObject.content.fields;
-        const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
-          claimed_rewards: rewardPoolFields.claimed_rewards,
-          exchange_rate_numerator: rewardPoolFields.exchange_rate_numerator,
-          exchange_rate_denominator: rewardPoolFields.exchange_rate_denominator,
-          rewards: rewardPoolFields.rewards,
-          spool_id: rewardPoolFields.spool_id
-        });
-        const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
-        const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
-        const calculatedRewardPoolData = calculateSpoolRewardPoolData(
-          parsedSpoolData,
-          parsedSpoolRewardPoolData,
-          calculatedSpoolData,
-          rewardCoinPrice,
-          rewardCoinDecimal
-        );
-        spool = {
-          marketCoinName,
-          symbol: query.utils.parseSymbol(marketCoinName),
-          coinType: query.utils.parseCoinType(coinName),
-          marketCoinType: query.utils.parseMarketCoinType(coinName),
-          rewardCoinType: isMarketCoin(rewardCoinName) ? query.utils.parseMarketCoinType(rewardCoinName) : query.utils.parseCoinType(rewardCoinName),
-          coinDecimal: query.utils.getCoinDecimal(coinName),
-          rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
-          coinPrice: coinPrices?.[coinName] ?? 0,
-          marketCoinPrice,
-          rewardCoinPrice,
-          maxPoint: parsedSpoolData.maxPoint,
-          distributedPoint: parsedSpoolData.distributedPoint,
-          maxStake: parsedSpoolData.maxStake,
-          ...calculatedSpoolData,
-          exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
-          exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
-          ...calculatedRewardPoolData
-        };
-      }
+        rewardCoinPrice,
+        maxPoint: parsedSpoolData.maxPoint,
+        distributedPoint: parsedSpoolData.distributedPoint,
+        maxStake: parsedSpoolData.maxStake,
+        ...calculatedSpoolData,
+        exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
+        exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
+        ...calculatedRewardPoolData
+      };
     }
   }
   return spool;
@@ -4201,7 +4124,7 @@ var getTotalValueLocked = async (query, indexer = false) => {
 var import_bignumber5 = __toESM(require("bignumber.js"));
 var import_sui_kit3 = require("@scallop-io/sui-kit");
 var import_bcs = require("@mysten/sui/bcs");
-var import_zod3 = require("zod");
+var import_zod2 = require("zod");
 var import_assert = __toESM(require("assert"));
 var getVescaKeys = async (utils, ownerAddress) => {
   const owner = ownerAddress || utils.suiKit.currentAddress();
@@ -4250,10 +4173,10 @@ var getVeScas = async ({
   }
   return result;
 };
-var SuiObjectRefZod = import_zod3.z.object({
-  objectId: import_zod3.z.string(),
-  digest: import_zod3.z.string(),
-  version: import_zod3.z.string()
+var SuiObjectRefZod = import_zod2.z.object({
+  objectId: import_zod2.z.string(),
+  digest: import_zod2.z.string(),
+  version: import_zod2.z.string()
 });
 var getVeSca = async (utils, veScaKey, ownerAddress) => {
   const tableId = utils.address.get(`vesca.tableId`);
@@ -4337,7 +4260,7 @@ var getTotalVeScaTreasuryAmount = async (utils, veScaTreasury) => {
     }
   });
   const results = res.results;
-  if (results && results[1].returnValues) {
+  if (results && results[1]?.returnValues) {
     const value = Uint8Array.from(results[1].returnValues[0][0]);
     const type = results[1].returnValues[0][1];
     (0, import_assert.default)(type === "u64", "Result type is not u64");
@@ -4387,16 +4310,16 @@ var queryVeScaKeyIdFromReferralBindings = async (address, refereeAddress) => {
 
 // src/queries/loyaltyProgramQuery.ts
 var import_bignumber6 = __toESM(require("bignumber.js"));
-var import_zod4 = require("zod");
-var rewardPoolFieldsZod = import_zod4.z.object({
-  balance: import_zod4.z.string(),
-  enable_claim: import_zod4.z.boolean()
+var import_zod3 = require("zod");
+var rewardPoolFieldsZod = import_zod3.z.object({
+  balance: import_zod3.z.string(),
+  enable_claim: import_zod3.z.boolean()
 }).transform((value) => ({
   totalPoolReward: (0, import_bignumber6.default)(value.balance).shiftedBy(-9).toNumber(),
   isClaimEnabled: value.enable_claim
 }));
-var userRewardFieldsZod = import_zod4.z.object({
-  value: import_zod4.z.string()
+var userRewardFieldsZod = import_zod3.z.object({
+  value: import_zod3.z.string()
 }).transform((value) => (0, import_bignumber6.default)(value.value).shiftedBy(-9).toNumber());
 var getLoyaltyProgramInformations = async (query, veScaKey) => {
   const rewardPool = query.address.get("loyaltyProgram.rewardPool");
@@ -4822,10 +4745,10 @@ var ScallopUtils = class {
               const feed = await this.cache.queryClient.fetchQuery({
                 queryKey: queryKeys.oracle.getPythLatestPriceFeed(priceId),
                 queryFn: async () => {
-                  return await pythConnection.getLatestPriceFeeds([priceId]);
+                  return await pythConnection.getLatestPriceFeeds([priceId]) ?? [];
                 }
               });
-              if (feed) {
+              if (feed[0]) {
                 const data = parseDataFromPythPriceFeed(feed[0], this.address);
                 this._priceMap.set(coinName, {
                   price: data.price,
@@ -5571,6 +5494,9 @@ var generateSpoolQuickMethod = ({
         stakeMarketCoinName,
         stakeAccountId
       );
+      if (stakeAccountIds.length === 0) {
+        throw new Error(`No stakeAccountIds found for user ${sender}`);
+      }
       if (typeof amountOrMarketCoin === "number") {
         const stakedMarketCoinAmount = await stakeHelper(
           builder,
@@ -6701,7 +6627,7 @@ var getSCoinTotalSupply = async ({
     typeArgs
   });
   const results = queryResults?.results;
-  if (results && results[0].returnValues) {
+  if (results && results[0]?.returnValues) {
     const value = Uint8Array.from(results[0].returnValues[0][0]);
     const type = results[0].returnValues[0][1];
     (0, import_assert2.default)(type === "u64", "Result type is not u64");
@@ -6776,6 +6702,88 @@ var getSCoinSwapRate = async (query, fromSCoin, toSCoin, underlyingCoinPrice) =>
 
 // src/models/scallopQuery.ts
 var import_utils23 = require("@mysten/sui/utils");
+
+// src/queries/isolatedAsset.ts
+var import_zod4 = require("zod");
+var isolatedAssetZod = import_zod4.z.object({
+  dataType: import_zod4.z.string(),
+  type: import_zod4.z.string(),
+  hasPublicTransfer: import_zod4.z.boolean(),
+  fields: import_zod4.z.object({
+    id: import_zod4.z.object({
+      id: import_zod4.z.string()
+    }),
+    name: import_zod4.z.object({
+      type: import_zod4.z.string()
+    }),
+    value: import_zod4.z.boolean()
+  })
+});
+var ISOLATED_ASSET_KEY = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::IsolatedAssetKey";
+var getIsolatedAssets = async (address) => {
+  try {
+    const marketObject = address.get("core.market");
+    const isolatedAssets = [];
+    if (!marketObject)
+      return isolatedAssets;
+    let hasNextPage = false;
+    let nextCursor = null;
+    const isIsolatedDynamicField = (dynamicField) => {
+      return dynamicField.name.type === ISOLATED_ASSET_KEY;
+    };
+    do {
+      const response = await address.cache.queryGetDynamicFields({
+        parentId: marketObject,
+        cursor: nextCursor,
+        limit: 10
+      });
+      if (!response)
+        break;
+      const isolatedAssetCoinTypes = response.data.filter(isIsolatedDynamicField).map(({ name }) => `0x${name.value.type.name}`);
+      isolatedAssets.push(...isolatedAssetCoinTypes);
+      if (response && response.hasNextPage && response.nextCursor) {
+        hasNextPage = true;
+        nextCursor = response.nextCursor;
+      } else {
+        hasNextPage = false;
+      }
+    } while (hasNextPage);
+    return isolatedAssets;
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+};
+var isIsolatedAsset = async (utils, coinName) => {
+  try {
+    const marketObject = utils.address.get("core.market");
+    const cachedData = utils.address.cache.queryClient.getQueryData([
+      "getDynamicFields",
+      marketObject
+    ]);
+    if (cachedData) {
+      const coinType2 = utils.parseCoinType(coinName);
+      return cachedData.includes(coinType2);
+    }
+    const coinType = utils.parseCoinType(coinName).slice(2);
+    const object = await utils.cache.queryGetDynamicFieldObject({
+      parentId: marketObject,
+      name: {
+        type: ISOLATED_ASSET_KEY,
+        value: coinType
+      }
+    });
+    const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
+    if (!parsedData.success)
+      return false;
+    return parsedData.data.fields.value;
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+};
+
+// src/models/scallopQuery.ts
 var ScallopQuery = class {
   constructor(params, instance) {
     this.params = params;
@@ -7612,7 +7620,7 @@ var ScallopClient = class {
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
     const obligations = await this.query.getObligations(sender);
-    const specificObligationId = obligationId || obligations?.[0]?.id;
+    const specificObligationId = obligationId || obligations[0]?.id;
     if (specificObligationId) {
       await txBlock.addCollateralQuick(
         amount,
@@ -7683,7 +7691,7 @@ var ScallopClient = class {
     txBlock.setSender(sender);
     const stakeMarketCoinName = this.utils.parseMarketCoinName(stakeCoinName);
     const stakeAccounts = await this.query.getStakeAccounts(stakeMarketCoinName);
-    const targetStakeAccount = stakeAccountId || stakeAccounts[0].id;
+    const targetStakeAccount = stakeAccountId || stakeAccounts[0]?.id;
     const marketCoin = await txBlock.depositQuick(amount, stakeCoinName, false);
     if (targetStakeAccount) {
       await txBlock.stakeQuick(
@@ -7818,7 +7826,7 @@ var ScallopClient = class {
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
     const stakeAccounts = await this.query.getStakeAccounts(stakeMarketCoinName);
-    const targetStakeAccount = stakeAccountId || stakeAccounts[0].id;
+    const targetStakeAccount = stakeAccountId || stakeAccounts[0]?.id;
     if (targetStakeAccount) {
       await txBlock.stakeQuick(amount, stakeMarketCoinName, targetStakeAccount);
     } else {