@scallop-io/sui-scallop-sdk 0.46.64 → 0.46.65

package/dist/queries/borrowIncentiveQuery.d.ts

@@ -1,5 +1,5 @@
 import type { ScallopAddress, ScallopQuery, ScallopUtils } from '../models';
-import type { SupportBorrowIncentiveCoins } from '../types';
+import type { SupportBorrowIncentiveCoins, BorrowIncentivePool } from '../types';
 /**
  * Query borrow incentive pools data.
  *
@@ -9,14 +9,14 @@ import type { SupportBorrowIncentiveCoins } from '../types';
  * @return Borrow incentive pools data.
  */
 export declare const queryBorrowIncentivePools: (query: ScallopQuery, borrowIncentiveCoinNames?: SupportBorrowIncentiveCoins[], indexer?: boolean) => Promise<{
-    eth?: import("../types").BorrowIncentivePool | undefined;
-    usdc?: import("../types").BorrowIncentivePool | undefined;
-    usdt?: import("../types").BorrowIncentivePool | undefined;
-    sui?: import("../types").BorrowIncentivePool | undefined;
-    afsui?: import("../types").BorrowIncentivePool | undefined;
-    hasui?: import("../types").BorrowIncentivePool | undefined;
-    vsui?: import("../types").BorrowIncentivePool | undefined;
-    sca?: import("../types").BorrowIncentivePool | undefined;
+    eth?: BorrowIncentivePool | undefined;
+    usdc?: BorrowIncentivePool | undefined;
+    usdt?: BorrowIncentivePool | undefined;
+    sui?: BorrowIncentivePool | undefined;
+    afsui?: BorrowIncentivePool | undefined;
+    hasui?: BorrowIncentivePool | undefined;
+    vsui?: BorrowIncentivePool | undefined;
+    sca?: BorrowIncentivePool | undefined;
 }>;
 /**
  * Query borrow incentive accounts data.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "0.46.64",
+  "version": "0.46.65",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",

package/src/queries/borrowIncentiveQuery.ts

@@ -18,6 +18,7 @@ import type {
   SupportBorrowIncentiveRewardCoins,
   BorrowIncentivePoolPoints,
   OptionalKeys,
+  BorrowIncentivePool,
 } from '../types';
 import BigNumber from 'bignumber.js';
 
@@ -31,13 +32,11 @@ import BigNumber from 'bignumber.js';
  */
 export const queryBorrowIncentivePools = async (
   query: ScallopQuery,
-  borrowIncentiveCoinNames?: SupportBorrowIncentiveCoins[],
+  borrowIncentiveCoinNames: SupportBorrowIncentiveCoins[] = [
+    ...SUPPORT_BORROW_INCENTIVE_POOLS,
+  ],
   indexer: boolean = false
 ) => {
-  borrowIncentiveCoinNames = borrowIncentiveCoinNames || [
-    ...SUPPORT_BORROW_INCENTIVE_POOLS,
-  ];
-
   const borrowIncentivePools: BorrowIncentivePools = {};
 
   const coinPrices = await query.utils.getCoinPrices(
@@ -52,18 +51,17 @@ export const queryBorrowIncentivePools = async (
   if (indexer) {
     const borrowIncentivePoolsIndexer =
       await query.indexer.getBorrowIncentivePools();
-    for (const borrowIncentivePool of Object.values(
-      borrowIncentivePoolsIndexer
-    )) {
-      if (!borrowIncentiveCoinNames.includes(borrowIncentivePool.coinName))
-        continue;
-      borrowIncentivePool.coinPrice =
-        coinPrices[borrowIncentivePool.coinName] ||
-        borrowIncentivePool.coinPrice;
-      // borrowIncentivePool.rewardCoinPrice =
-      //   coinPrices[rewardCoinName] || borrowIncentivePool.rewardCoinPrice;
-      borrowIncentivePools[borrowIncentivePool.coinName] = borrowIncentivePool;
-    }
+
+    const updateBorrowIncentivePool = (pool: BorrowIncentivePool) => {
+      if (!borrowIncentiveCoinNames.includes(pool.coinName)) return;
+      pool.coinPrice = coinPrices[pool.coinName] || pool.coinPrice;
+      borrowIncentivePools[pool.coinName] = pool;
+    };
+
+    Object.values(borrowIncentivePoolsIndexer).forEach(
+      updateBorrowIncentivePool
+    );
+
     return borrowIncentivePools;
   }
 

package/src/queries/coreQuery.ts

@@ -60,20 +60,25 @@ export const queryMarket = async (
 
   if (indexer) {
     const marketIndexer = await query.indexer.getMarket();
-    for (const pool of Object.values(marketIndexer.pools)) {
-      pool.coinPrice = coinPrices[pool.coinName] || pool.coinPrice;
-      pool.coinWrappedType = query.utils.getCoinWrappedType(pool.coinName);
-    }
-    for (const collateral of Object.values(marketIndexer.collaterals)) {
-      collateral.coinPrice =
-        coinPrices[collateral.coinName] || collateral.coinPrice;
-      collateral.coinWrappedType = query.utils.getCoinWrappedType(
-        collateral.coinName
-      );
-    }
+
+    const updatePools = (item: MarketPool) => {
+      item.coinPrice = coinPrices[item.coinName] || item.coinPrice;
+      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
+      pools[item.coinName] = item;
+    };
+
+    const updateCollaterals = (item: MarketCollateral) => {
+      item.coinPrice = coinPrices[item.coinName] || item.coinPrice;
+      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
+      collaterals[item.coinName] = item;
+    };
+
+    Object.values(marketIndexer.pools).forEach(updatePools);
+    Object.values(marketIndexer.collaterals).forEach(updateCollaterals);
+
     return {
-      pools: marketIndexer.pools,
-      collaterals: marketIndexer.collaterals,
+      pools,
+      collaterals,
     };
   }
 
@@ -221,10 +226,9 @@ export const queryMarket = async (
  */
 export const getMarketPools = async (
   query: ScallopQuery,
-  poolCoinNames?: SupportPoolCoins[],
+  poolCoinNames: SupportPoolCoins[] = [...SUPPORT_POOLS],
   indexer: boolean = false
 ) => {
-  poolCoinNames = poolCoinNames || [...SUPPORT_POOLS];
   const marketId = query.address.get('core.market');
   const marketObjectResponse = await query.cache.queryGetObject(marketId, {
     showContent: true,
@@ -235,15 +239,18 @@ export const getMarketPools = async (
 
   if (indexer) {
     const marketPoolsIndexer = await query.indexer.getMarketPools();
-    for (const marketPool of Object.values(marketPoolsIndexer)) {
-      if (!poolCoinNames.includes(marketPool.coinName)) continue;
+
+    const updateMarketPool = (marketPool: MarketPool) => {
+      if (!poolCoinNames.includes(marketPool.coinName)) return;
       marketPool.coinPrice =
         coinPrices[marketPool.coinName] || marketPool.coinPrice;
       marketPool.coinWrappedType = query.utils.getCoinWrappedType(
         marketPool.coinName
       );
       marketPools[marketPool.coinName] = marketPool;
-    }
+    };
+
+    Object.values(marketPoolsIndexer).forEach(updateMarketPool);
 
     return marketPools;
   }
@@ -290,6 +297,10 @@ export const getMarketPool = async (
   let interestModel: InterestModel | undefined;
   let borrowFeeRate: { value: string } | undefined;
 
+  coinPrice =
+    coinPrice ||
+    (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
+
   if (indexer) {
     const marketPoolIndexer = await query.indexer.getMarketPool(poolCoinName);
     marketPoolIndexer.coinPrice = coinPrice || marketPoolIndexer.coinPrice;
@@ -309,10 +320,6 @@ export const getMarketPool = async (
       })
     )?.data;
 
-  coinPrice =
-    coinPrice ||
-    (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
-
   if (marketObject) {
     if (marketObject.content && 'fields' in marketObject.content) {
       const fields = marketObject.content.fields as any;
@@ -507,33 +514,31 @@ export const getMarketPool = async (
  */
 export const getMarketCollaterals = async (
   query: ScallopQuery,
-  collateralCoinNames?: SupportCollateralCoins[],
+  collateralCoinNames: SupportCollateralCoins[] = [...SUPPORT_COLLATERALS],
   indexer: boolean = false
 ) => {
-  collateralCoinNames = collateralCoinNames || [...SUPPORT_COLLATERALS];
   const marketId = query.address.get('core.market');
-  const [marketObjectResponse, coinPrices] = await Promise.all([
-    await query.cache.queryGetObject(marketId, {
-      showContent: true,
-    }),
-    await query.utils.getCoinPrices(collateralCoinNames ?? []),
-  ]);
+  const coinPrices = await query.utils.getCoinPrices(collateralCoinNames ?? []);
   const marketCollaterals: MarketCollaterals = {};
 
   if (indexer) {
     const marketCollateralsIndexer = await query.indexer.getMarketCollaterals();
-    for (const marketCollateral of Object.values(marketCollateralsIndexer)) {
-      if (!collateralCoinNames.includes(marketCollateral.coinName)) continue;
+    const updateMarketCollateral = (marketCollateral: MarketCollateral) => {
+      if (!collateralCoinNames.includes(marketCollateral.coinName)) return;
       marketCollateral.coinPrice =
         coinPrices[marketCollateral.coinName] || marketCollateral.coinPrice;
       marketCollateral.coinWrappedType = query.utils.getCoinWrappedType(
         marketCollateral.coinName
       );
       marketCollaterals[marketCollateral.coinName] = marketCollateral;
-    }
+    };
+    Object.values(marketCollateralsIndexer).forEach(updateMarketCollateral);
     return marketCollaterals;
   }
 
+  const marketObjectResponse = await query.cache.queryGetObject(marketId, {
+    showContent: true,
+  });
   await Promise.allSettled(
     collateralCoinNames.map(async (collateralCoinName) => {
       const marketCollateral = await getMarketCollateral(
@@ -570,6 +575,12 @@ export const getMarketCollateral = async (
   marketObject?: SuiObjectData | null,
   coinPrice?: number
 ) => {
+  coinPrice =
+    coinPrice ||
+    (await query.utils.getCoinPrices([collateralCoinName]))?.[
+      collateralCoinName
+    ];
+
   if (indexer) {
     const marketCollateralIndexer =
       await query.indexer.getMarketCollateral(collateralCoinName);
@@ -595,12 +606,6 @@ export const getMarketCollateral = async (
       })
     )?.data;
 
-  coinPrice =
-    coinPrice ||
-    (await query.utils.getCoinPrices([collateralCoinName]))?.[
-      collateralCoinName
-    ];
-
   if (marketObject) {
     if (marketObject.content && 'fields' in marketObject.content) {
       const fields = marketObject.content.fields as any;

package/src/queries/spoolQuery.ts

@@ -31,10 +31,9 @@ import type {
  */
 export const getSpools = async (
   query: ScallopQuery,
-  stakeMarketCoinNames?: SupportStakeMarketCoins[],
+  stakeMarketCoinNames: SupportStakeMarketCoins[] = [...SUPPORT_SPOOLS],
   indexer: boolean = false
 ) => {
-  stakeMarketCoinNames = stakeMarketCoinNames || [...SUPPORT_SPOOLS];
   const stakeCoinNames = stakeMarketCoinNames.map((stakeMarketCoinName) =>
     query.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName)
   );
@@ -52,8 +51,8 @@ export const getSpools = async (
 
   if (indexer) {
     const spoolsIndexer = await query.indexer.getSpools();
-    for (const spool of Object.values(spoolsIndexer)) {
-      if (!stakeMarketCoinNames.includes(spool.marketCoinName)) continue;
+    const updateSpools = (spool: Spool) => {
+      if (!stakeMarketCoinNames.includes(spool.marketCoinName)) return;
       const coinName = query.utils.parseCoinName<SupportStakeCoins>(
         spool.marketCoinName
       );
@@ -68,7 +67,8 @@ export const getSpools = async (
       spool.rewardCoinPrice =
         coinPrices[rewardCoinName] || spool.rewardCoinPrice;
       spools[spool.marketCoinName] = spool;
-    }
+    };
+    Object.values(spoolsIndexer).forEach(updateSpools);
 
     return spools;
   }
@@ -116,6 +116,7 @@ export const getSpool = async (
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool: Spool | undefined = undefined;
+  coinPrices = coinPrices || (await query.utils.getCoinPrices([coinName]));
 
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);