@scallop-io/sui-scallop-sdk 1.4.0 → 1.4.1

package/src/queries/borrowIncentiveQuery.ts

@@ -1,5 +1,9 @@
 import { normalizeStructTag } from '@mysten/sui/utils';
-import { SUPPORT_BORROW_INCENTIVE_POOLS } from '../constants';
+import {
+  sCoinRawNameToName,
+  SUPPORT_BORROW_INCENTIVE_POOLS,
+  SUPPORT_BORROW_INCENTIVE_REWARDS,
+} from '../constants';
 import {
   parseOriginBorrowIncentivePoolData,
   parseOriginBorrowIncentiveAccountData,
@@ -17,6 +21,7 @@ import type {
   OptionalKeys,
   BorrowIncentivePool,
   CoinPrices,
+  MarketPools,
 } from '../types';
 import BigNumber from 'bignumber.js';
 
@@ -55,11 +60,14 @@ export const getBorrowIncentivePools = async (
     ...SUPPORT_BORROW_INCENTIVE_POOLS,
   ],
   indexer: boolean = false,
+  marketPools?: MarketPools,
   coinPrices?: CoinPrices
 ) => {
   const borrowIncentivePools: BorrowIncentivePools = {};
-
-  coinPrices = coinPrices ?? (await query.utils.getCoinPrices()) ?? {};
+  marketPools =
+    marketPools ??
+    (await query.getMarketPools(undefined, { coinPrices, indexer }));
+  coinPrices = coinPrices ?? (await query.getAllCoinPrices({ marketPools }));
 
   if (indexer) {
     const borrowIncentivePoolsIndexer =
@@ -67,7 +75,13 @@ export const getBorrowIncentivePools = async (
 
     const updateBorrowIncentivePool = (pool: BorrowIncentivePool) => {
       if (!borrowIncentiveCoinNames.includes(pool.coinName)) return;
-      pool.coinPrice = coinPrices[pool.coinName] ?? pool.coinPrice;
+      pool.coinPrice = coinPrices[pool.coinName] || pool.coinPrice;
+      for (const sCoinName of SUPPORT_BORROW_INCENTIVE_REWARDS) {
+        if (pool.points[sCoinName]) {
+          pool.points[sCoinName].coinPrice =
+            coinPrices[sCoinName] ?? pool.points[sCoinName].coinPrice;
+        }
+      }
       borrowIncentivePools[pool.coinName] = pool;
     };
 
@@ -94,7 +108,6 @@ export const getBorrowIncentivePools = async (
       query.utils.parseCoinNameFromType<SupportBorrowIncentiveCoins>(
         poolCoinType
       );
-
     const poolCoinPrice = coinPrices?.[poolCoinName] ?? 0;
     const poolCoinDecimal = query.utils.getCoinDecimal(poolCoinName);
 
@@ -102,17 +115,21 @@ export const getBorrowIncentivePools = async (
     if (!borrowIncentiveCoinNames.includes(poolCoinName)) {
       continue;
     }
-    // pool points for borrow incentive reward ('sui' and 'sca')
+
+    // pool points for borrow incentive reward
     for (const [coinName, poolPoint] of Object.entries(
       parsedBorrowIncentivePoolData.poolPoints
     )) {
-      const rewardCoinType = normalizeStructTag(poolPoint.pointType);
-      const rewardCoinName =
-        query.utils.parseCoinNameFromType<SupportBorrowIncentiveRewardCoins>(
-          rewardCoinType
-        );
-      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+      const rewardCoinType = poolPoint.pointType;
+      let rewardCoinName = query.utils.parseCoinNameFromType(
+        rewardCoinType
+      ) as SupportBorrowIncentiveRewardCoins;
+      // handle for scoin name
+      if (sCoinRawNameToName[rewardCoinName]) {
+        rewardCoinName = sCoinRawNameToName[rewardCoinName];
+      }
       const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
 
       const symbol = query.utils.parseSymbol(rewardCoinName);
       const coinDecimal = query.utils.getCoinDecimal(rewardCoinName);

package/src/queries/coreQuery.ts

@@ -247,7 +247,7 @@ export const getMarketPools = async (
   const marketObjectResponse = await query.cache.queryGetObject(marketId, {
     showContent: true,
   });
-  coinPrices = (await query.utils.getCoinPrices(poolCoinNames)) ?? {};
+  coinPrices = coinPrices ?? (await query.utils.getCoinPrices());
 
   const marketPools: MarketPools = {};
 
@@ -305,9 +305,7 @@ export const getMarketPool = async (
   marketObject?: SuiObjectData | null,
   coinPrice?: number
 ): Promise<MarketPool | undefined> => {
-  coinPrice =
-    coinPrice ||
-    (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
+  coinPrice = coinPrice ?? (await query.utils.getCoinPrices())?.[poolCoinName];
 
   if (indexer) {
     const marketPoolIndexer = await query.indexer.getMarketPool(poolCoinName);
@@ -536,8 +534,7 @@ export const getMarketCollaterals = async (
   indexer: boolean = false
 ) => {
   const marketId = query.address.get('core.market');
-  const coinPrices =
-    (await query.utils.getCoinPrices(collateralCoinNames)) ?? {};
+  const coinPrices = (await query.utils.getCoinPrices()) ?? {};
   const marketCollaterals: MarketCollaterals = {};
 
   if (indexer) {
@@ -595,10 +592,7 @@ export const getMarketCollateral = async (
   coinPrice?: number
 ): Promise<MarketCollateral | undefined> => {
   coinPrice =
-    coinPrice ||
-    (await query.utils.getCoinPrices([collateralCoinName]))?.[
-      collateralCoinName
-    ];
+    coinPrice ?? (await query.utils.getCoinPrices())?.[collateralCoinName];
 
   if (indexer) {
     const marketCollateralIndexer =

package/src/queries/portfolioQuery.ts

@@ -1,6 +1,5 @@
 import BigNumber from 'bignumber.js';
 import {
-  SUPPORT_BORROW_INCENTIVE_REWARDS,
   SUPPORT_COLLATERALS,
   SUPPORT_POOLS,
   SUPPORT_SPOOLS,
@@ -50,7 +49,7 @@ export const getLendings = async (
     (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName)
   ) as SupportStakeMarketCoins[];
 
-  const coinPrices = await query.utils.getCoinPrices(poolCoinNames);
+  const coinPrices = await query.utils.getCoinPrices();
   const marketPools = await query.getMarketPools(poolCoinNames, {
     indexer,
     coinPrices,
@@ -124,9 +123,7 @@ export const getLending = async (
 ) => {
   const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
   coinPrice =
-    coinPrice ??
-    (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ??
-    0;
+    coinPrice ?? (await query.utils.getCoinPrices())?.[poolCoinName] ?? 0;
 
   marketPool =
     marketPool ??
@@ -355,9 +352,9 @@ export const getObligationAccount = async (
   const collateralAssetCoinNames: SupportCollateralCoins[] = [
     ...SUPPORT_COLLATERALS,
   ];
+  market = market ?? (await query.queryMarket({ indexer }));
   coinPrices =
-    coinPrices ?? (await query.utils.getCoinPrices(collateralAssetCoinNames));
-  market = market ?? (await query.queryMarket({ indexer, coinPrices }));
+    coinPrices ?? (await query.getAllCoinPrices({ marketPools: market.pools }));
   coinAmounts =
     coinAmounts ||
     (await query.getCoinAmounts(collateralAssetCoinNames, ownerAddress));
@@ -526,64 +523,70 @@ export const getObligationAccount = async (
     const borrowIncentivePool = borrowIncentivePools[coinName];
     if (borrowIncentivePool) {
       const rewards: ObligationBorrowIcentiveReward[] = [];
-      for (const rewardCoinName of SUPPORT_BORROW_INCENTIVE_REWARDS) {
-        const accountPoint = borrowIncentiveAccount.pointList[rewardCoinName];
-        const poolPoint = borrowIncentivePool.points[rewardCoinName];
-
-        if (accountPoint && poolPoint) {
-          let availableClaimAmount = BigNumber(0);
-          let availableClaimCoin = BigNumber(0);
-          const accountBorrowedAmount = BigNumber(accountPoint.weightedAmount);
-          const baseIndexRate = 1_000_000_000;
-          const increasedPointRate = poolPoint.currentPointIndex
-            ? Math.max(
-                BigNumber(poolPoint.currentPointIndex - accountPoint.index)
-                  .dividedBy(baseIndexRate)
-                  .toNumber(),
-                0
-              )
-            : 1;
-          availableClaimAmount = availableClaimAmount.plus(
-            accountBorrowedAmount
-              .multipliedBy(increasedPointRate)
-              .plus(accountPoint.points)
-          );
-          availableClaimCoin = availableClaimAmount.shiftedBy(
-            -1 * poolPoint.coinDecimal
-          );
-
-          // for veSCA
-          const weightScale = BigNumber(1_000_000_000_000);
-          const boostValue = BigNumber(accountPoint.weightedAmount)
-            .div(
-              BigNumber(borrowIncentiveAccount.debtAmount)
-                .multipliedBy(poolPoint.baseWeight)
-                .dividedBy(weightScale)
-            )
-            .isFinite()
-            ? BigNumber(accountPoint.weightedAmount)
-                .div(
-                  BigNumber(borrowIncentiveAccount.debtAmount)
-                    .multipliedBy(poolPoint.baseWeight)
-                    .dividedBy(weightScale)
+      Object.entries(borrowIncentiveAccount.pointList).forEach(
+        ([key, accountPoint]) => {
+          const poolPoint =
+            borrowIncentivePool.points[
+              key as SupportBorrowIncentiveRewardCoins
+            ];
+
+          if (accountPoint && poolPoint) {
+            let availableClaimAmount = BigNumber(0);
+            let availableClaimCoin = BigNumber(0);
+            const accountBorrowedAmount = BigNumber(
+              accountPoint.weightedAmount
+            );
+            const baseIndexRate = 1_000_000_000;
+            const increasedPointRate = poolPoint.currentPointIndex
+              ? Math.max(
+                  BigNumber(poolPoint.currentPointIndex - accountPoint.index)
+                    .dividedBy(baseIndexRate)
+                    .toNumber(),
+                  0
                 )
-                .toNumber()
-            : 1;
-
-          if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
-            rewards.push({
-              coinName: poolPoint.coinName,
-              coinType: poolPoint.coinType,
-              symbol: poolPoint.symbol,
-              coinDecimal: poolPoint.coinDecimal,
-              coinPrice: poolPoint.coinPrice,
-              availableClaimAmount: availableClaimAmount.toNumber(),
-              availableClaimCoin: availableClaimCoin.toNumber(),
-              boostValue,
-            });
+              : 1;
+            availableClaimAmount = availableClaimAmount.plus(
+              accountBorrowedAmount
+                .multipliedBy(increasedPointRate)
+                .plus(accountPoint.points)
+            );
+            availableClaimCoin = availableClaimAmount.shiftedBy(
+              -1 * poolPoint.coinDecimal
+            );
+
+            // for veSCA
+            const weightScale = BigNumber(1_000_000_000_000);
+            const boostValue = BigNumber(accountPoint.weightedAmount)
+              .div(
+                BigNumber(borrowIncentiveAccount.debtAmount)
+                  .multipliedBy(poolPoint.baseWeight)
+                  .dividedBy(weightScale)
+              )
+              .isFinite()
+              ? BigNumber(accountPoint.weightedAmount)
+                  .div(
+                    BigNumber(borrowIncentiveAccount.debtAmount)
+                      .multipliedBy(poolPoint.baseWeight)
+                      .dividedBy(weightScale)
+                  )
+                  .toNumber()
+              : 1;
+
+            if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
+              rewards.push({
+                coinName: poolPoint.coinName,
+                coinType: poolPoint.coinType,
+                symbol: poolPoint.symbol,
+                coinDecimal: poolPoint.coinDecimal,
+                coinPrice: poolPoint.coinPrice,
+                availableClaimAmount: availableClaimAmount.toNumber(),
+                availableClaimCoin: availableClaimCoin.toNumber(),
+                boostValue,
+              });
+            }
           }
         }
-      }
+      );
 
       if (
         Object.keys(borrowIncentivePool.points).some((coinName: any) => {

package/src/queries/priceQuery.ts

@@ -1,6 +1,14 @@
 import { SuiObjectData } from '@mysten/sui/client';
-import type { ScallopAddress } from '../models';
-import type { SupportAssetCoins } from '../types';
+import type { ScallopAddress, ScallopQuery } from '../models';
+import type {
+  CoinPrices,
+  MarketPools,
+  OptionalKeys,
+  SupportAssetCoins,
+  SupportSCoin,
+} from '../types';
+import { SUPPORT_SCOIN } from 'src/constants/common';
+import BigNumber from 'bignumber.js';
 
 /**
  * Get price from pyth fee object.
@@ -126,3 +134,28 @@ export const getPythPrices = async (
     {} as Record<SupportAssetCoins, number>
   );
 };
+
+export const getAllCoinPrices = async (
+  query: ScallopQuery,
+  marketPools?: MarketPools,
+  coinPrices?: CoinPrices
+) => {
+  coinPrices = coinPrices ?? (await query.utils.getCoinPrices());
+  marketPools =
+    marketPools ?? (await query.getMarketPools(undefined, { coinPrices }));
+  if (!marketPools) {
+    throw new Error(`Failed to fetch market pool for getAllCoinPrices`);
+  }
+  const sCoinPrices: OptionalKeys<Record<SupportSCoin, number>> = {};
+  SUPPORT_SCOIN.forEach((sCoinName) => {
+    const coinName = query.utils.parseCoinName(sCoinName);
+    sCoinPrices[sCoinName] = BigNumber(coinPrices[coinName] ?? 0)
+      .multipliedBy(marketPools[coinName]?.conversionRate ?? 1)
+      .toNumber();
+  });
+
+  return {
+    ...coinPrices,
+    ...sCoinPrices,
+  };
+};

package/src/queries/sCoinQuery.ts

@@ -153,7 +153,7 @@ export const getSCoinSwapRate = async (
   const BtoSCoinBRate = 1 / marketPools[1]!.conversionRate;
 
   const calcAtoBRate = async () => {
-    const prices = await query.utils.getCoinPrices([fromCoinName, toCoinName]);
+    const prices = await query.utils.getCoinPrices();
     if (!prices[fromCoinName] || !prices[toCoinName]) {
       throw new Error('Failed to fetch the coin prices');
     }

package/src/queries/spoolQuery.ts

@@ -71,7 +71,6 @@ export const getSpools = async (
     };
     Object.values(spoolsIndexer).forEach(updateSpools);
 
-    // console.log(spools);
     return spools;
   }
 
@@ -122,7 +121,7 @@ export const getSpool = async (
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool: Spool | undefined = undefined;
-  coinPrices = coinPrices || (await query.utils.getCoinPrices([coinName]));
+  coinPrices = coinPrices || (await query.utils.getCoinPrices());
 
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);
@@ -152,8 +151,7 @@ export const getSpool = async (
   }
 
   const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
-  coinPrices =
-    coinPrices || (await query.utils.getCoinPrices([coinName, rewardCoinName]));
+  coinPrices = coinPrices || (await query.utils.getCoinPrices());
 
   const spoolObject = spoolObjectResponse[0];
   const rewardPoolObject = spoolObjectResponse[1];

package/src/types/builder/borrowIncentive.ts

@@ -4,10 +4,7 @@ import type {
 } from '@scallop-io/sui-kit';
 import type { TransactionResult } from '@mysten/sui/transactions';
 import type { ScallopBuilder } from '../../models';
-import type {
-  SupportBorrowIncentiveCoins,
-  SupportBorrowIncentiveRewardCoins,
-} from '../constant';
+import type { SupportBorrowIncentiveRewardCoins } from '../constant';
 
 export type BorrowIncentiveIds = {
   borrowIncentivePkg: string;
@@ -35,7 +32,6 @@ export type BorrowIncentiveNormalMethods = {
   claimBorrowIncentive: (
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
-    coinName: SupportBorrowIncentiveCoins,
     rewardType: SupportBorrowIncentiveRewardCoins
   ) => TransactionResult;
   deactivateBoost: (obligation: SuiObjectArg, veScaKey: SuiObjectArg) => void;
@@ -43,23 +39,22 @@ export type BorrowIncentiveNormalMethods = {
 
 export type BorrowIncentiveQuickMethods = {
   stakeObligationQuick(
-    obligation?: SuiObjectArg,
-    obligationKey?: SuiObjectArg
+    obligation?: string,
+    obligationKey?: string
   ): Promise<void>;
   stakeObligationWithVeScaQuick(
-    obligation?: SuiObjectArg,
-    obligationKey?: SuiObjectArg,
-    veScaKey?: SuiObjectArg
+    obligation?: string,
+    obligationKey?: string,
+    veScaKey?: string
   ): Promise<void>;
   unstakeObligationQuick(
-    obligation?: SuiObjectArg,
-    obligationKey?: SuiObjectArg
+    obligation?: string,
+    obligationKey?: string
   ): Promise<void>;
   claimBorrowIncentiveQuick(
-    coinName: SupportBorrowIncentiveCoins,
     rewardType: SupportBorrowIncentiveRewardCoins,
-    obligation?: SuiObjectArg,
-    obligationKey?: SuiObjectArg
+    obligation?: string,
+    obligationKey?: string
   ): Promise<TransactionResult>;
 };
 

package/src/types/constant/common.ts

@@ -23,8 +23,7 @@ export type SupportCoins =
 export type SupportAssetCoins =
   | SupportPoolCoins
   | SupportCollateralCoins
-  | SupportStakeRewardCoins
-  | SupportBorrowIncentiveRewardCoins;
+  | SupportStakeRewardCoins;
 export type SupportPoolCoins = (typeof SUPPORT_POOLS)[number];
 export type SupportCollateralCoins = (typeof SUPPORT_COLLATERALS)[number];
 export type SupportMarketCoins =

package/src/types/utils.ts

@@ -1,18 +1,10 @@
-import type { SupportAssetCoins } from './constant';
+import type { SupportCoins } from './constant';
 
 export type OptionalKeys<T> = {
   [K in keyof T]?: T[K];
 };
 
-export type CoinPrices = OptionalKeys<Record<SupportAssetCoins, number>>;
-
-export type PriceMap = Map<
-  SupportAssetCoins,
-  {
-    price: number;
-    publishTime: number;
-  }
->;
+export type CoinPrices = OptionalKeys<Record<SupportCoins, number>>;
 
 export type PoolAddressInfo = {
   name: string;

package/src/utils/query.ts

@@ -546,93 +546,6 @@ export const calculateBorrowIncentivePoolPointData = (
   };
 };
 
-// /**
-//  *  Parse origin borrow incentive reward pool data to a more readable format.
-//  *
-//  * @param originBorrowIncentiveRewardPoolData - Origin borrow incentive reward pool data
-//  * @return Parsed borrow incentive reward pool data
-//  */
-// export const parseOriginBorrowIncentiveRewardPoolData = (
-//   originBorrowIncentiveRewardPoolData: OriginBorrowIncentiveRewardPoolData
-// ): ParsedBorrowIncentiveRewardPoolData => {
-//   return {
-//     rewardType: normalizeStructTag(
-//       originBorrowIncentiveRewardPoolData.reward_type.name
-//     ),
-//     claimedRewards: Number(originBorrowIncentiveRewardPoolData.claimed_rewards),
-//     exchangeRateNumerator: Number(
-//       originBorrowIncentiveRewardPoolData.exchange_rate_numerator
-//     ),
-//     exchangeRateDenominator: Number(
-//       originBorrowIncentiveRewardPoolData.exchange_rate_denominator
-//     ),
-//     remainingRewards: Number(
-//       originBorrowIncentiveRewardPoolData.remaining_reward
-//     ),
-//   };
-// };
-
-// export const calculateBorrowIncentiveRewardPoolData = (
-//   parsedBorrowIncentivePoolData: ParsedBorrowIncentivePoolData,
-//   parsedBorrowIncentiveRewardPoolData: ParsedBorrowIncentiveRewardPoolData,
-//   calculatedBorrowIncentivePoolData: CalculatedBorrowIncentivePoolData,
-//   rewardCoinPrice: number,
-//   rewardCoinDecimal: number
-// ): CalculatedBorrowIncentiveRewardPoolData => {
-//   const rateYearFactor = 365 * 24 * 60 * 60;
-
-//   const rewardPerSec = BigNumber(
-//     calculatedBorrowIncentivePoolData.distributedPointPerSec
-//   )
-//     .multipliedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator)
-//     .dividedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator);
-//   const totalRewardAmount = BigNumber(parsedBorrowIncentivePoolData.maxPoint)
-//     .multipliedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator)
-//     .dividedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator);
-//   const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
-//   const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
-//   const remaindRewardAmount = BigNumber(
-//     parsedBorrowIncentiveRewardPoolData.remainingRewards
-//   );
-//   const remaindRewardCoin = remaindRewardAmount.shiftedBy(
-//     -1 * rewardCoinDecimal
-//   );
-//   const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
-//   const claimedRewardAmount = BigNumber(
-//     parsedBorrowIncentiveRewardPoolData.claimedRewards
-//   );
-//   const claimedRewardCoin = claimedRewardAmount.shiftedBy(
-//     -1 * rewardCoinDecimal
-//   );
-//   const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
-
-//   const rewardValueForYear = BigNumber(rewardPerSec)
-//     .shiftedBy(-1 * rewardCoinDecimal)
-//     .multipliedBy(rateYearFactor)
-//     .multipliedBy(rewardCoinPrice);
-//   const rewardRate = rewardValueForYear
-//     .dividedBy(calculatedBorrowIncentivePoolData.stakedValue)
-//     .isFinite()
-//     ? rewardValueForYear
-//         .dividedBy(calculatedBorrowIncentivePoolData.stakedValue)
-//         .toNumber()
-//     : Infinity;
-
-//   return {
-//     rewardApr: rewardRate,
-//     totalRewardAmount: totalRewardAmount.toNumber(),
-//     totalRewardCoin: totalRewardCoin.toNumber(),
-//     totalRewardValue: totalRewardValue.toNumber(),
-//     remaindRewardAmount: remaindRewardAmount.toNumber(),
-//     remaindRewardCoin: remaindRewardCoin.toNumber(),
-//     remaindRewardValue: remaindRewardValue.toNumber(),
-//     claimedRewardAmount: claimedRewardAmount.toNumber(),
-//     claimedRewardCoin: claimedRewardCoin.toNumber(),
-//     claimedRewardValue: claimedRewardValue.toNumber(),
-//     rewardPerSec: rewardPerSec.toNumber(),
-//   };
-// };
-
 export const parseOriginBorrowIncentiveAccountPoolPointData = (
   originBorrowIncentiveAccountPoolPointData: OriginBorrowIncentiveAccountPoolData
 ): ParsedBorrowIncentiveAccountPoolData => {