@scallop-io/sui-scallop-sdk 1.5.3 → 2.0.0-alpha.2

package/src/queries/portfolioQuery.ts

@@ -1,14 +1,8 @@
 import BigNumber from 'bignumber.js';
-import {
-  SUPPORT_COLLATERALS,
-  SUPPORT_POOLS,
-  SUPPORT_SPOOLS,
-} from '../constants';
 import { minBigNumber, estimatedFactor } from 'src/utils';
 import type { ScallopQuery } from '../models';
 import type {
   Market,
-  SupportPoolCoins,
   MarketPool,
   Spool,
   StakeAccount,
@@ -16,16 +10,10 @@ import type {
   Lending,
   ObligationAccounts,
   ObligationAccount,
-  SupportStakeMarketCoins,
-  SupportCollateralCoins,
   CoinAmounts,
   CoinPrices,
-  SupportMarketCoins,
   TotalValueLocked,
-  SupportBorrowIncentiveCoins,
   ObligationBorrowIcentiveReward,
-  SupportBorrowIncentiveRewardCoins,
-  SupportAssetCoins,
   MarketPools,
   MarketCollaterals,
 } from '../types';
@@ -44,7 +32,7 @@ import { normalizeStructTag, SUI_TYPE_ARG } from '@scallop-io/sui-kit';
  */
 export const getLendings = async (
   query: ScallopQuery,
-  poolCoinNames: SupportPoolCoins[] = [...SUPPORT_POOLS],
+  poolCoinNames: string[] = [...query.constants.whitelist.lending],
   ownerAddress?: string,
   marketPools?: MarketPools,
   coinPrices?: CoinPrices,
@@ -54,8 +42,10 @@ export const getLendings = async (
     query.utils.parseMarketCoinName(poolCoinName)
   );
   const stakeMarketCoinNames = marketCoinNames.filter((marketCoinName) =>
-    (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName)
-  ) as SupportStakeMarketCoins[];
+    ([...query.constants.whitelist.spool] as readonly string[]).includes(
+      marketCoinName
+    )
+  ) as string[];
 
   coinPrices = coinPrices ?? (await query.utils.getCoinPrices());
   marketPools =
@@ -123,7 +113,7 @@ export const getLendings = async (
  */
 export const getLending = async (
   query: ScallopQuery,
-  poolCoinName: SupportPoolCoins,
+  poolCoinName: string,
   ownerAddress?: string,
   indexer: boolean = false,
   marketPool?: MarketPool,
@@ -150,8 +140,10 @@ export const getLending = async (
 
   spool =
     (spool ??
-    (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName))
-      ? await query.getSpool(marketCoinName as SupportStakeMarketCoins, {
+    ([...query.constants.whitelist.spool] as readonly string[]).includes(
+      marketCoinName
+    ))
+      ? await query.getSpool(marketCoinName as string, {
           indexer,
           marketPool,
           coinPrices: {
@@ -164,11 +156,10 @@ export const getLending = async (
 
   stakeAccounts =
     stakeAccounts ||
-    (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName)
-      ? await query.getStakeAccounts(
-          marketCoinName as SupportStakeMarketCoins,
-          ownerAddress
-        )
+    ([...query.constants.whitelist.spool] as readonly string[]).includes(
+      marketCoinName
+    )
+      ? await query.getStakeAccounts(marketCoinName as string, ownerAddress)
       : [];
   coinAmount =
     coinAmount || (await query.getCoinAmount(poolCoinName, ownerAddress));
@@ -375,18 +366,15 @@ export const getObligationAccount = async (
   coinPrices?: CoinPrices,
   coinAmounts?: CoinAmounts
 ) => {
-  const coinNames: SupportAssetCoins[] = Array.from(
-    new Set([...SUPPORT_POOLS, ...SUPPORT_COLLATERALS])
-  );
-  const collateralAssetCoinNames = [
-    ...SUPPORT_COLLATERALS,
-  ] as SupportCollateralCoins[];
-
   market = market ?? (await query.getMarketPools(undefined, { indexer }));
   coinPrices =
     coinPrices ?? (await query.getAllCoinPrices({ marketPools: market.pools }));
   coinAmounts =
-    coinAmounts ?? (await query.getCoinAmounts(coinNames, ownerAddress));
+    coinAmounts ??
+    (await query.getCoinAmounts(
+      Array.from(query.constants.whitelist.lending),
+      ownerAddress
+    ));
 
   const [obligationQuery, borrowIncentivePools, borrowIncentiveAccounts] =
     await Promise.all([
@@ -410,12 +398,13 @@ export const getObligationAccount = async (
   let totalBorrowedValue = BigNumber(0);
   let totalBorrowedValueWithWeight = BigNumber(0);
 
-  for (const assetCoinName of collateralAssetCoinNames) {
+  for (const assetCoinName of Array.from(
+    query.constants.whitelist.collateral
+  )) {
     const collateral = obligationQuery?.collaterals.find((collateral) => {
-      const collateralCoinName =
-        query.utils.parseCoinNameFromType<SupportCollateralCoins>(
-          collateral.type.name
-        );
+      const collateralCoinName = query.utils.parseCoinNameFromType(
+        collateral.type.name
+      );
       return assetCoinName === collateralCoinName;
     });
 
@@ -474,15 +463,17 @@ export const getObligationAccount = async (
     }
   }
 
-  const borrowAssetCoinNames: SupportPoolCoins[] = [
-    ...new Set([...Object.values(market.pools).map((pool) => pool.coinName)]),
+  const borrowAssetCoinNames: string[] = [
+    ...new Set([
+      ...Object.values(market.pools)
+        .filter((t) => !!t)
+        .map((pool) => pool.coinName),
+    ]),
   ];
 
   for (const assetCoinName of borrowAssetCoinNames) {
     const debt = obligationQuery?.debts.find((debt) => {
-      const poolCoinName = query.utils.parseCoinNameFromType<SupportPoolCoins>(
-        debt.type.name
-      );
+      const poolCoinName = query.utils.parseCoinNameFromType(debt.type.name);
       return assetCoinName === poolCoinName;
     });
 
@@ -546,7 +537,9 @@ export const getObligationAccount = async (
   for (const [poolCoinName, borrowIncentiveAccount] of Object.entries(
     borrowIncentiveAccounts
   )) {
-    const coinName = poolCoinName as SupportBorrowIncentiveCoins;
+    if (!borrowIncentiveAccount) continue;
+
+    const coinName = poolCoinName as string;
     const borrowIncentivePool = borrowIncentivePools[coinName];
     if (borrowIncentivePool) {
       const rewards: ObligationBorrowIcentiveReward[] = [];
@@ -599,11 +592,6 @@ export const getObligationAccount = async (
                   .toNumber()
               : 1;
 
-            // console.log({
-            //   availableClaimAmount: availableClaimAmount.toString(),
-            //   coinName: poolPoint.coinName,
-            //   coinType: poolPoint.coinType,
-            // });
             if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
               rewards.push({
                 coinName: poolPoint.coinName,
@@ -623,9 +611,7 @@ export const getObligationAccount = async (
       if (
         Object.keys(borrowIncentivePool.points).some((coinName: any) => {
           const rewardApr =
-            borrowIncentivePool.points[
-              coinName as SupportBorrowIncentiveRewardCoins
-            ]?.rewardApr;
+            borrowIncentivePool.points[coinName as string]?.rewardApr;
           return (
             rewardApr !== Infinity &&
             typeof rewardApr == 'number' &&
@@ -706,8 +692,8 @@ export const getObligationAccount = async (
   for (const [collateralCoinName, obligationCollateral] of Object.entries(
     obligationAccount.collaterals
   )) {
-    const marketCollateral =
-      market.collaterals[collateralCoinName as SupportCollateralCoins];
+    if (!obligationCollateral) continue;
+    const marketCollateral = market.collaterals[collateralCoinName as string];
     if (marketCollateral) {
       let estimatedAvailableWithdrawAmount = BigNumber(
         obligationAccount.totalAvailableCollateralValue
@@ -746,7 +732,8 @@ export const getObligationAccount = async (
   for (const [poolCoinName, obligationDebt] of Object.entries(
     obligationAccount.debts
   )) {
-    const marketPool = market.pools[poolCoinName as SupportPoolCoins];
+    if (!obligationDebt) continue;
+    const marketPool = market.pools[poolCoinName as string];
     if (marketPool) {
       const estimatedRequiredRepayAmount = BigNumber(
         obligationDebt.requiredRepayAmount
@@ -836,6 +823,7 @@ export const getTotalValueLocked = async (
   }
 
   for (const pool of Object.values(market.pools)) {
+    if (!pool) continue;
     supplyLendingValue = supplyLendingValue.plus(
       BigNumber(pool.supplyCoin).multipliedBy(pool.coinPrice)
     );
@@ -846,6 +834,7 @@ export const getTotalValueLocked = async (
 
   // console.dir(market.collaterals, { depth: null });
   for (const collateral of Object.values(market.collaterals)) {
+    if (!collateral) continue;
     supplyCollateralValue = supplyCollateralValue.plus(
       BigNumber(collateral.depositCoin).multipliedBy(collateral.coinPrice)
     );
@@ -897,7 +886,9 @@ export const getUserPortfolio = async (
 
   // get pending rewards (spool and borrow incentive)
   const parsedLendings = Object.values(lendings)
-    .filter((t) => t.availableWithdrawCoin > 0)
+    .filter(
+      (t): t is NonNullable<typeof t> => !!t && t.availableWithdrawCoin > 0
+    )
     .map((lending) => ({
       suppliedCoin: lending.availableWithdrawCoin,
       suppliedValue: lending.suppliedValue,
@@ -928,7 +919,10 @@ export const getUserPortfolio = async (
         totalUnhealthyCollateralInUsd:
           obligationAccount.totalUnhealthyCollateralValue,
         borrowedPools: Object.values(obligationAccount.debts)
-          .filter((debt) => debt.borrowedCoin > 0)
+          .filter(
+            (debt): debt is NonNullable<typeof debt> =>
+              !!debt && debt.borrowedCoin > 0
+          )
           .map((debt) => ({
             coinName: debt.coinName,
             symbol: debt.symbol,
@@ -942,7 +936,9 @@ export const getUserPortfolio = async (
             incentiveInfos: Object.values(
               borrowIncentivePools[debt.coinName]?.points ?? {}
             )
-              .filter((t) => isFinite(t.rewardApr))
+              .filter(
+                (t): t is NonNullable<typeof t> => !!t && isFinite(t.rewardApr)
+              )
               .map((t) => ({
                 coinName: t.coinName,
                 symbol: t.symbol,
@@ -955,16 +951,18 @@ export const getUserPortfolio = async (
 
   const pendingLendingRewards = Object.values(lendings).reduce(
     (acc, reward) => {
-      if (reward.availableClaimCoin === 0) return acc;
-      if (!acc[reward.symbol]) {
-        acc[reward.symbol] = {
-          symbol: reward.symbol,
-          coinType: normalizeStructTag(SUI_TYPE_ARG), // @TODO: for now lending reward is all in SUI
-          coinPrice: reward.coinPrice,
-          pendingRewardInCoin: reward.availableClaimCoin,
-        };
-      } else {
-        acc[reward.symbol].pendingRewardInCoin += reward.availableClaimCoin;
+      if (reward) {
+        if (reward.availableClaimCoin === 0) return acc;
+        if (!acc[reward.symbol]) {
+          acc[reward.symbol] = {
+            symbol: reward.symbol,
+            coinType: normalizeStructTag(SUI_TYPE_ARG), // @TODO: for now lending reward is all in SUI
+            coinPrice: reward.coinPrice,
+            pendingRewardInCoin: reward.availableClaimCoin,
+          };
+        } else {
+          acc[reward.symbol].pendingRewardInCoin += reward.availableClaimCoin;
+        }
       }
       return acc;
     },
@@ -984,7 +982,7 @@ export const getUserPortfolio = async (
     .reduce(
       (acc, curr) => {
         Object.values(curr.borrowIncentives).forEach((incentive) => {
-          incentive.rewards.forEach((reward) => {
+          incentive?.rewards.forEach((reward) => {
             if (reward.availableClaimCoin === 0) return acc;
             if (!acc[reward.coinName]) {
               acc[reward.coinName] = {

package/src/queries/priceQuery.ts

@@ -1,14 +1,8 @@
 import { SuiObjectData } from '@mysten/sui/client';
 import type { ScallopAddress, ScallopQuery } from '../models';
-import type {
-  CoinPrices,
-  MarketPools,
-  OptionalKeys,
-  SupportAssetCoins,
-  SupportSCoin,
-} from '../types';
-import { SUPPORT_SCOIN } from 'src/constants/common';
+import type { CoinPrices, MarketPools, OptionalKeys } from '../types';
 import BigNumber from 'bignumber.js';
+import { ScallopConstants } from 'src/models/scallopConstants';
 
 /**
  * Get price from pyth fee object.
@@ -23,7 +17,7 @@ export const getPythPrice = async (
   }: {
     address: ScallopAddress;
   },
-  assetCoinName: SupportAssetCoins,
+  assetCoinName: string,
   priceFeedObject?: SuiObjectData | null
 ) => {
   const pythFeedObjectId = address.get(
@@ -70,15 +64,15 @@ export const getPythPrice = async (
 
 export const getPythPrices = async (
   {
-    address,
+    constants,
   }: {
-    address: ScallopAddress;
+    constants: ScallopConstants;
   },
-  assetCoinNames: SupportAssetCoins[]
+  assetCoinNames: string[]
 ) => {
   const pythPriceFeedIds = assetCoinNames.reduce(
     (prev, assetCoinName) => {
-      const pythPriceFeed = address.get(
+      const pythPriceFeed = constants.address.get(
         `core.coins.${assetCoinName}.oracle.pyth.feedObject`
       );
       if (pythPriceFeed) {
@@ -90,11 +84,11 @@ export const getPythPrices = async (
       }
       return prev;
     },
-    {} as Record<string, SupportAssetCoins[]>
+    {} as Record<string, string[]>
   );
 
   // Fetch multiple objects at once to save rpc calls
-  const priceFeedObjects = await address.cache.queryGetObjects(
+  const priceFeedObjects = await constants.address.cache.queryGetObjects(
     Object.keys(pythPriceFeedIds)
   );
 
@@ -105,7 +99,7 @@ export const getPythPrices = async (
       });
       return prev;
     },
-    {} as Record<SupportAssetCoins, SuiObjectData>
+    {} as Record<string, SuiObjectData>
   );
 
   return (
@@ -114,8 +108,8 @@ export const getPythPrices = async (
         async ([assetCoinName, priceFeedObject]) => ({
           coinName: assetCoinName,
           price: await getPythPrice(
-            { address },
-            assetCoinName as SupportAssetCoins,
+            constants,
+            assetCoinName as string,
             priceFeedObject
           ),
         })
@@ -123,10 +117,10 @@ export const getPythPrices = async (
     )
   ).reduce(
     (prev, curr) => {
-      prev[curr.coinName as SupportAssetCoins] = curr.price;
+      prev[curr.coinName as string] = curr.price;
       return prev;
     },
-    {} as Record<SupportAssetCoins, number>
+    {} as Record<string, number>
   );
 };
 
@@ -150,8 +144,8 @@ export const getAllCoinPrices = async (
     throw new Error(`Failed to fetch market pool for getAllCoinPrices`);
   }
 
-  const sCoinPrices: OptionalKeys<Record<SupportSCoin, number>> = {};
-  SUPPORT_SCOIN.forEach((sCoinName) => {
+  const sCoinPrices: OptionalKeys<Record<string, number>> = {};
+  query.constants.whitelist.scoin.forEach((sCoinName) => {
     const coinName = query.utils.parseCoinName(sCoinName);
     sCoinPrices[sCoinName] = BigNumber(coinPrices[coinName] ?? 0)
       .multipliedBy(marketPools[coinName]?.conversionRate ?? 1)

package/src/queries/sCoinQuery.ts

@@ -1,9 +1,8 @@
 import { bcs } from '@mysten/sui/bcs';
 import assert from 'assert';
 import BigNumber from 'bignumber.js';
-import { SUPPORT_SCOIN } from 'src/constants';
 import { ScallopQuery, ScallopUtils } from 'src/models';
-import { OptionalKeys, SupportSCoin, sCoinBalance } from 'src/types';
+import { OptionalKeys, sCoinBalance } from 'src/types';
 
 /**
  * Get total supply of sCoin
@@ -17,7 +16,7 @@ export const getSCoinTotalSupply = async (
   }: {
     utils: ScallopUtils;
   },
-  sCoinName: SupportSCoin
+  sCoinName: string
 ): Promise<sCoinBalance> => {
   const sCoinPkgId = utils.address.get('scoin.id');
   // get treasury
@@ -60,11 +59,11 @@ export const getSCoinAmounts = async (
   }: {
     utils: ScallopUtils;
   },
-  sCoinNames: SupportSCoin[] = [...SUPPORT_SCOIN],
+  sCoinNames: string[] = [...utils.constants.whitelist.scoin],
   ownerAddress?: string
 ) => {
   const owner = ownerAddress || utils.suiKit.currentAddress();
-  const sCoins = {} as OptionalKeys<Record<SupportSCoin, number>>;
+  const sCoins = {} as OptionalKeys<Record<string, number>>;
 
   await Promise.allSettled(
     sCoinNames.map(async (sCoinName) => {
@@ -90,7 +89,7 @@ export const getSCoinAmount = async (
   }: {
     utils: ScallopUtils;
   },
-  sCoinName: SupportSCoin,
+  sCoinName: string,
   ownerAddress?: string
 ) => {
   const owner = ownerAddress || utils.suiKit.currentAddress();
@@ -102,18 +101,18 @@ export const getSCoinAmount = async (
   return BigNumber(coinBalance?.totalBalance ?? '0').toNumber();
 };
 
-const isSupportStakeCoins = (value: string): value is SupportSCoin => {
-  return SUPPORT_SCOIN.includes(value as SupportSCoin);
-};
-
-const checkAssetParams = (fromSCoin: SupportSCoin, toSCoin: SupportSCoin) => {
+const checkAssetParams = (
+  utils: ScallopUtils,
+  fromSCoin: string,
+  toSCoin: string
+) => {
   if (fromSCoin === toSCoin)
     throw new Error('fromAsset and toAsset must be different');
 
-  if (!isSupportStakeCoins(fromSCoin))
+  if (!utils.constants.whitelist.scoin.has(fromSCoin))
     throw new Error('fromAsset is not supported');
 
-  if (!isSupportStakeCoins(toSCoin)) {
+  if (!utils.constants.whitelist.scoin.has(toSCoin)) {
     throw new Error('toAsset is not supported');
   }
 };
@@ -129,11 +128,11 @@ const checkAssetParams = (fromSCoin: SupportSCoin, toSCoin: SupportSCoin) => {
  */
 export const getSCoinSwapRate = async (
   query: ScallopQuery,
-  fromSCoin: SupportSCoin,
-  toSCoin: SupportSCoin,
+  fromSCoin: string,
+  toSCoin: string,
   underlyingCoinPrice?: number
 ) => {
-  checkAssetParams(fromSCoin, toSCoin);
+  checkAssetParams(query.utils, fromSCoin, toSCoin);
   const fromCoinName = query.utils.parseCoinName(fromSCoin);
   const toCoinName = query.utils.parseCoinName(toSCoin);