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

package/src/models/scallopUtils.ts

@@ -1,55 +1,32 @@
-import { SUI_TYPE_ARG, normalizeStructTag } from '@mysten/sui/utils';
+import {
+  SUI_TYPE_ARG,
+  normalizeStructTag,
+  parseStructTag,
+} from '@mysten/sui/utils';
 import { SuiKit } from '@scallop-io/sui-kit';
 import { SuiPriceServiceConnection } from '@pythnetwork/pyth-sui-js';
 import { ScallopAddress } from './scallopAddress';
-import {
-  ADDRESS_ID,
-  PROTOCOL_OBJECT_ID,
-  SUPPORT_POOLS,
-  SUPPORT_COLLATERALS,
-  spoolRewardCoins,
-  coinDecimals,
-  wormholeCoinIds,
-  voloCoinIds,
-  coinIds,
-  UNLOCK_ROUND_DURATION,
-  MAX_LOCK_DURATION,
-  SUPPORT_SCOIN,
-  sCoinIds,
-  suiBridgeCoins,
-  COIN_GECKGO_IDS,
-  POOL_ADDRESSES,
-  sCoinTypeToName,
-  sCoinRawNameToName,
-} from '../constants';
+import { UNLOCK_ROUND_DURATION, MAX_LOCK_DURATION } from '../constants';
 import { getPythPrices, queryObligation } from '../queries';
-import {
-  parseDataFromPythPriceFeed,
-  isMarketCoin,
-  parseAssetSymbol,
-  findClosestUnlockRound,
-  isSuiBridgeAsset,
-  isWormholeAsset,
-} from '../utils';
-import { PYTH_ENDPOINTS, PYTH_FEED_IDS } from 'src/constants/pyth';
+import { parseDataFromPythPriceFeed, findClosestUnlockRound } from '../utils';
 import { ScallopCache } from './scallopCache';
 import type {
   ScallopUtilsParams,
-  SupportCoins,
-  SupportAssetCoins,
-  SupportMarketCoins,
-  SupportStakeMarketCoins,
   CoinPrices,
   CoinWrappedType,
-  SupportSCoin,
   ScallopUtilsInstanceParams,
-  SupportSuiBridgeCoins,
-  SupportWormholeCoins,
-  PoolAddressInfo,
+  PoolAddress,
 } from '../types';
 import { queryKeys } from 'src/constants';
 import type { SuiObjectArg, SuiTxBlock } from '@scallop-io/sui-kit';
 import { newSuiKit } from './suiKit';
+import { ScallopConstants } from './scallopConstants';
+
+const PYTH_ENDPOINTS: {
+  [k in 'mainnet']: string[];
+} = {
+  mainnet: ['https://hermes.pyth.network', 'https://scallop.rpc.p2p.world'],
+};
 
 /**
  * @description
@@ -65,11 +42,11 @@ import { newSuiKit } from './suiKit';
  */
 export class ScallopUtils {
   public readonly params: ScallopUtilsParams;
-  public readonly isTestnet: boolean;
 
   public suiKit: SuiKit;
   public address: ScallopAddress;
   public cache: ScallopCache;
+  public constants: ScallopConstants;
   public walletAddress: string;
 
   public constructor(
@@ -82,40 +59,50 @@ export class ScallopUtils {
     };
     this.walletAddress =
       params.walletAddress ?? instance?.suiKit?.currentAddress() ?? '';
+
     this.suiKit =
-      instance?.suiKit ?? instance?.address?.cache.suiKit ?? newSuiKit(params);
+      instance?.suiKit ??
+      instance?.constants?.cache.suiKit ??
+      newSuiKit(params);
 
-    if (instance?.address) {
-      this.address = instance.address;
-      this.cache = this.address.cache;
-    } else {
-      this.cache = new ScallopCache(this.params, {
+    this.cache =
+      instance?.constants?.cache ??
+      new ScallopCache(this.params, {
         suiKit: this.suiKit,
       });
-      this.address =
-        instance?.address ??
-        new ScallopAddress(
-          {
-            id: params?.addressId ?? ADDRESS_ID,
-            network: params?.networkType,
-            forceInterface: params?.forceAddressesInterface,
-          },
-          {
-            cache: this.cache,
-          }
-        );
-    }
-    this.isTestnet = params.networkType
-      ? params.networkType === 'testnet'
-      : false;
+
+    this.address =
+      instance?.constants?.address ??
+      new ScallopAddress(this.params, {
+        cache: this.cache,
+      });
+
+    this.constants =
+      instance?.constants ??
+      new ScallopConstants(this.params, {
+        address: this.address,
+      });
   }
+
+  get whitelist() {
+    return this.constants.whitelist;
+  }
+
   // -------------- TYPE GUARDS --------------
-  public isSuiBridgeAsset(coinName: any): coinName is SupportSuiBridgeCoins {
-    return isSuiBridgeAsset(coinName);
+  public isSuiBridgeAsset(coinName: any) {
+    return this.constants.whitelist.suiBridge.has(coinName);
   }
 
-  public isWormholeAsset(coinName: any): coinName is SupportWormholeCoins {
-    return isWormholeAsset(coinName);
+  public isWormholeAsset(coinName: any) {
+    return this.constants.whitelist.wormhole.has(coinName);
+  }
+
+  public isMarketCoin(coinName: string) {
+    const assetCoinName = coinName.slice(1).toLowerCase() as string;
+    return (
+      coinName.charAt(0).toLowerCase() === 's' &&
+      this.whitelist.lending.has(assetCoinName)
+    );
   }
 
   /**
@@ -137,8 +124,8 @@ export class ScallopUtils {
    * @param coinName - Specific support coin name.
    * @return Symbol string.
    */
-  public parseSymbol(coinName: SupportCoins) {
-    return parseAssetSymbol(coinName);
+  public parseSymbol(coinName: string) {
+    return this.constants.poolAddresses[coinName]?.symbol ?? '';
   }
 
   /**
@@ -152,60 +139,11 @@ export class ScallopUtils {
    * @param coinName - Specific support coin name.
    * @return Coin type.
    */
-  public parseCoinType(
-    coinName: SupportCoins,
-    useOldMarketCoin: boolean = false
-  ) {
-    // try parse scoin first
-    if (sCoinIds[coinName as SupportSCoin] && !useOldMarketCoin) {
-      return sCoinIds[coinName as SupportSCoin];
-    }
-    coinName = isMarketCoin(coinName) ? this.parseCoinName(coinName) : coinName;
-    const coinPackageId =
-      this.address.get(`core.coins.${coinName}.id`) ||
-      coinIds[coinName] ||
-      undefined;
-    if (!coinPackageId) {
-      throw Error(`Coin ${coinName} is not supported`);
-    }
-    if (coinName === 'sui')
-      return normalizeStructTag(`${coinPackageId}::sui::SUI`);
-    if (coinName === 'blub')
-      return normalizeStructTag(`${coinPackageId}::BLUB::BLUB`);
-    if (coinName === 'sbwbtc')
-      return normalizeStructTag(`${coinPackageId}::btc::BTC`);
-
-    const wormHolePackageIds = [
-      this.address.get('core.coins.wusdc.id') ?? wormholeCoinIds.wusdc,
-      this.address.get('core.coins.wusdt.id') ?? wormholeCoinIds.wusdt,
-      this.address.get('core.coins.weth.id') ?? wormholeCoinIds.weth,
-      this.address.get('core.coins.wbtc.id') ?? wormholeCoinIds.wbtc,
-      this.address.get('core.coins.wsol.id') ?? wormholeCoinIds.wsol,
-      this.address.get('core.coins.wapt.id') ?? wormholeCoinIds.wapt,
-    ];
-    const voloPackageIds = [
-      this.address.get('core.coins.vsui.id') ?? voloCoinIds.vsui,
-    ];
-
-    const suiBridgePackageIds = Object.values<SupportSuiBridgeCoins>(
-      suiBridgeCoins
-    ).reduce((curr, coinName) => {
-      curr.push(
-        this.address.get(`core.coins.${coinName}.id`) ?? coinIds[coinName]
-      );
-      return curr;
-    }, [] as string[]);
-    if (wormHolePackageIds.includes(coinPackageId)) {
-      return `${coinPackageId}::coin::COIN`;
-    } else if (voloPackageIds.includes(coinPackageId)) {
-      return `${coinPackageId}::cert::CERT`;
-    } else if (suiBridgePackageIds.includes(coinPackageId)) {
-      // handle sui bridge assets
-      const typeCoinName = coinName.slice(2);
-      return `${coinPackageId}::${typeCoinName}::${typeCoinName.toUpperCase()}`;
-    } else {
-      return `${coinPackageId}::${coinName}::${coinName.toUpperCase()}`;
+  public parseCoinType(coinName: string, useOldMarketCoin: boolean = false) {
+    if (useOldMarketCoin) {
+      return this.constants.coinNameToOldMarketCoinTypeMap[coinName] ?? '';
     }
+    return this.constants.coinNameToCoinTypeMap[coinName] ?? '';
   }
 
   /**
@@ -214,18 +152,13 @@ export class ScallopUtils {
    * @param coinName - Specific support coin name.
    * @return sCoin name.
    */
-  public parseSCoinName<T extends SupportSCoin>(
-    coinName: SupportCoins | SupportMarketCoins
-  ) {
+  public parseSCoinName<T extends string>(coinName: string) {
     // need more check because swapt has no sCoin type
-    if (
-      isMarketCoin(coinName) &&
-      SUPPORT_SCOIN.includes(coinName as SupportSCoin)
-    ) {
+    if (this.isMarketCoin(coinName) && this.whitelist.scoin.has(coinName)) {
       return coinName as T;
     } else {
       const marketCoinName = `s${coinName}`;
-      if (SUPPORT_SCOIN.includes(marketCoinName as SupportSCoin)) {
+      if (this.whitelist.scoin.has(marketCoinName)) {
         return marketCoinName as T;
       }
       return undefined;
@@ -240,7 +173,7 @@ export class ScallopUtils {
    * @return sCoin name
    */
   public parseSCoinTypeNameToMarketCoinName(coinName: string) {
-    return sCoinRawNameToName[coinName] ?? coinName;
+    return this.constants.sCoinRawNameToScoinNameMap[coinName] ?? coinName;
   }
 
   /**
@@ -248,8 +181,8 @@ export class ScallopUtils {
    * @param sCoinName
    * @returns sCoin type
    */
-  public parseSCoinType(sCoinName: SupportSCoin) {
-    return sCoinIds[sCoinName];
+  public parseSCoinType(sCoinName: string) {
+    return this.constants.sCoinTypes[sCoinName] ?? '';
   }
 
   /**
@@ -258,7 +191,7 @@ export class ScallopUtils {
    * @returns sCoin name
    */
   public parseSCoinNameFromType(sCoinType: string) {
-    return sCoinTypeToName[sCoinType];
+    return this.constants.sCoinTypeToSCoinNameMap[sCoinType];
   }
 
   /**
@@ -266,7 +199,7 @@ export class ScallopUtils {
    * @param sCoinName
    * @returns coin type
    */
-  public parseUnderlyingSCoinType(sCoinName: SupportSCoin) {
+  public parseUnderlyingSCoinType(sCoinName: string) {
     const coinName = this.parseCoinName(sCoinName);
     return this.parseCoinType(coinName);
   }
@@ -276,7 +209,7 @@ export class ScallopUtils {
    * @param sCoinName
    * @returns sCoin treasury id
    */
-  public getSCoinTreasury(sCoinName: SupportSCoin) {
+  public getSCoinTreasury(sCoinName: string) {
     return this.address.get(`scoin.coins.${sCoinName}.treasury`);
   }
 
@@ -287,11 +220,12 @@ export class ScallopUtils {
    * @param coinName - Specific support coin name.
    * @return Market coin type.
    */
-  public parseMarketCoinType(coinName: SupportCoins) {
-    const protocolObjectId =
-      this.address.get('core.object') || PROTOCOL_OBJECT_ID;
-    const coinType = this.parseCoinType(coinName, true);
-    return `${protocolObjectId}::reserve::MarketCoin<${coinType}>`;
+  public parseMarketCoinType(coinName: string) {
+    const coinType = this.parseCoinType(
+      this.isMarketCoin(coinName) ? this.parseCoinName(coinName) : coinName,
+      true
+    );
+    return coinType;
   }
 
   /**
@@ -304,74 +238,25 @@ export class ScallopUtils {
    * @param coinType - Specific support coin type.
    * @return Coin Name.
    */
-  public parseCoinNameFromType<T extends SupportAssetCoins>(
-    coinType: string
-  ): T extends SupportAssetCoins ? T : SupportAssetCoins;
-  public parseCoinNameFromType<T extends SupportMarketCoins>(
-    coinType: string
-  ): T extends SupportMarketCoins ? T : SupportMarketCoins;
-  public parseCoinNameFromType<T extends SupportCoins>(
-    coinType: string
-  ): T extends SupportCoins ? T : SupportCoins;
-  public parseCoinNameFromType<T extends SupportSCoin>(
-    coinType: string
-  ): T extends SupportSCoin ? T : SupportSCoin;
   public parseCoinNameFromType(coinType: string) {
     coinType = normalizeStructTag(coinType);
-    if (sCoinTypeToName[coinType]) {
-      return sCoinTypeToName[coinType] as SupportSCoin;
+    const { address, module, name, typeParams } = parseStructTag(coinType);
+    const isMarketCoinType =
+      address === this.constants.protocolObjectId &&
+      module === 'reserve' &&
+      name === 'MarketCoin';
+
+    if (isMarketCoinType) {
+      return this.parseMarketCoinName(
+        parseStructTag(typeParams as any).name.toLowerCase()
+      );
     }
-
-    const coinTypeRegex = new RegExp(`((0x[^:]+::[^:]+::[^<>]+))(?![^<>]*<)`);
-    const coinTypeMatch = coinType.match(coinTypeRegex);
-    const isMarketCoinType = coinType.includes('reserve::MarketCoin');
-    coinType = coinTypeMatch?.[1] ?? coinType;
-
-    const wormholeCoinTypeMap: Record<string, SupportAssetCoins> = {
-      [`${
-        this.address.get('core.coins.wusdc.id') ?? wormholeCoinIds.wusdc
-      }::coin::COIN`]: 'wusdc',
-      [`${
-        this.address.get('core.coins.wusdt.id') ?? wormholeCoinIds.wusdt
-      }::coin::COIN`]: 'wusdt',
-      [`${
-        this.address.get('core.coins.weth.id') ?? wormholeCoinIds.weth
-      }::coin::COIN`]: 'weth',
-      [`${
-        this.address.get('core.coins.wbtc.id') ?? wormholeCoinIds.wbtc
-      }::coin::COIN`]: 'wbtc',
-      [`${
-        this.address.get('core.coins.wsol.id') ?? wormholeCoinIds.wsol
-      }::coin::COIN`]: 'wsol',
-      [`${
-        this.address.get('core.coins.wapt.id') ?? wormholeCoinIds.wapt
-      }::coin::COIN`]: 'wapt',
-    };
-    const voloCoinTypeMap: Record<string, SupportAssetCoins> = {
-      [`${
-        this.address.get('core.coins.vsui.id') ?? voloCoinIds.vsui
-      }::cert::CERT`]: 'vsui',
-    };
-
-    const suiBridgeTypeMap = Object.values<SupportSuiBridgeCoins>(
-      suiBridgeCoins
-    ).reduce(
-      (curr, coinName) => {
-        curr[this.parseCoinType(coinName)] = coinName;
-        return curr;
-      },
-      {} as Record<string, SupportSuiBridgeCoins>
-    );
-
     const assetCoinName =
-      wormholeCoinTypeMap[coinType] ||
-      voloCoinTypeMap[coinType] ||
-      suiBridgeTypeMap[coinType] ||
-      (coinType.split('::')[2].toLowerCase() as SupportAssetCoins);
-
-    return isMarketCoinType
-      ? this.parseMarketCoinName(assetCoinName)
-      : assetCoinName;
+      this.constants.coinTypeToCoinNameMap[coinType] ||
+      this.constants.sCoinTypeToSCoinNameMap[coinType] ||
+      parseStructTag(coinType).name.toLowerCase();
+
+    return assetCoinName;
   }
 
   /**
@@ -380,7 +265,7 @@ export class ScallopUtils {
    * @param marketCoinName - Specific support market coin name.
    * @return Coin Name.
    */
-  public parseCoinName<T extends SupportAssetCoins>(marketCoinName: string) {
+  public parseCoinName<T extends string>(marketCoinName: string) {
     return marketCoinName.slice(1) as T;
   }
 
@@ -390,9 +275,7 @@ export class ScallopUtils {
    * @param coinName - Specific support coin name.
    * @return Market coin name.
    */
-  public parseMarketCoinName<T extends SupportMarketCoins>(
-    coinName: SupportCoins
-  ) {
+  public parseMarketCoinName<T extends string>(coinName: string) {
     return `s${coinName}` as T;
   }
 
@@ -402,10 +285,8 @@ export class ScallopUtils {
    * @param stakeMarketCoinName - Support stake market coin.
    * @return Spool reward coin name.
    */
-  public getSpoolRewardCoinName = (
-    stakeMarketCoinName: SupportStakeMarketCoins
-  ) => {
-    return spoolRewardCoins[stakeMarketCoinName];
+  public getSpoolRewardCoinName = () => {
+    return 'sui'; // No further plan to incentivize other spools
   };
 
   /**
@@ -413,8 +294,8 @@ export class ScallopUtils {
    *
    * return Coin decimal.
    */
-  public getCoinDecimal(coinName: SupportCoins) {
-    return coinDecimals[coinName];
+  public getCoinDecimal(coinName: string) {
+    return this.constants.coinDecimals[coinName] ?? 0;
   }
 
   /**
@@ -422,7 +303,7 @@ export class ScallopUtils {
    *
    * return Coin wrapped type.
    */
-  public getCoinWrappedType(assetCoinName: SupportAssetCoins): CoinWrappedType {
+  public getCoinWrappedType(assetCoinName: string): CoinWrappedType {
     if (this.isSuiBridgeAsset(assetCoinName)) {
       return {
         from: 'Sui Bridge',
@@ -531,27 +412,25 @@ export class ScallopUtils {
    * @return  Asset coin price.
    */
   public async getCoinPrices(
-    _: SupportAssetCoins[] = [
-      ...new Set([...SUPPORT_POOLS, ...SUPPORT_COLLATERALS]),
-    ] as SupportAssetCoins[]
+    coinNames: string[] = [
+      ...new Set([
+        ...this.constants.whitelist.lending,
+        ...this.constants.whitelist.collateral,
+      ]),
+    ] as string[]
   ) {
     let coinPrices: CoinPrices = {};
 
-    const endpoints =
-      this.params.pythEndpoints ??
-      PYTH_ENDPOINTS[this.isTestnet ? 'testnet' : 'mainnet'];
+    const endpoints = this.params.pythEndpoints ?? PYTH_ENDPOINTS['mainnet'];
 
-    const failedRequests: Set<SupportAssetCoins> = new Set([
-      ...SUPPORT_POOLS,
-      ...SUPPORT_COLLATERALS,
-    ]);
+    const failedRequests: Set<string> = new Set(coinNames);
 
     for (const endpoint of endpoints) {
       const priceIdPairs = Array.from(failedRequests.values()).reduce(
         (acc, coinName) => {
           const priceId =
             this.address.get(`core.coins.${coinName}.oracle.pyth.feed`) ??
-            PYTH_FEED_IDS[coinName];
+            this.constants.poolAddresses[coinName]?.pythFeed;
           acc.push([coinName, priceId]);
           return acc;
         },
@@ -575,10 +454,10 @@ export class ScallopUtils {
         });
         if (feeds) {
           feeds.forEach((feed, idx) => {
-            const coinName = priceIdPairs[idx][0] as SupportAssetCoins;
-            const data = parseDataFromPythPriceFeed(feed, this.address);
-            coinPrices[coinName as SupportAssetCoins] = data.price;
-            failedRequests.delete(coinName as SupportAssetCoins); // remove success price feed to prevent duplicate request on the next endpoint
+            const coinName = priceIdPairs[idx][0] as string;
+            const data = parseDataFromPythPriceFeed(feed, this.constants);
+            coinPrices[coinName as string] = data.price;
+            failedRequests.delete(coinName as string); // remove success price feed to prevent duplicate request on the next endpoint
           });
         }
       } catch (e: any) {
@@ -666,20 +545,11 @@ export class ScallopUtils {
    * Get detailed contract address and price id information for supported pool in Scallop
    * @returns Supported pool informations
    */
-  public getSupportedPoolAddresses(): PoolAddressInfo[] {
-    return SUPPORT_POOLS.map((poolName) => {
-      const sCoinName = this.parseSCoinName(poolName)!;
-      return {
-        name: this.parseSymbol(poolName),
-        coingeckoId: COIN_GECKGO_IDS[poolName],
-        decimal: coinDecimals[poolName],
-        pythFeedId: PYTH_FEED_IDS[poolName],
-        ...POOL_ADDRESSES[poolName],
-        sCoinAddress: sCoinIds[sCoinName],
-        marketCoinAddress: this.parseMarketCoinType(poolName),
-        coinAddress: this.parseCoinType(poolName),
-        sCoinName: sCoinName ? this.parseSymbol(sCoinName) : undefined,
-      };
-    });
+  public getSupportedPoolAddresses(): PoolAddress[] {
+    return this.constants.poolAddresses
+      ? Object.values(this.constants.poolAddresses).filter(
+          (address): address is PoolAddress => address !== undefined
+        )
+      : [];
   }
 }

package/src/queries/borrowIncentiveQuery.ts

@@ -1,8 +1,4 @@
 import { normalizeStructTag } from '@mysten/sui/utils';
-import {
-  SUPPORT_BORROW_INCENTIVE_POOLS,
-  SUPPORT_BORROW_INCENTIVE_REWARDS,
-} from '../constants';
 import {
   parseOriginBorrowIncentivePoolData,
   parseOriginBorrowIncentiveAccountData,
@@ -14,11 +10,8 @@ import type {
   BorrowIncentivePools,
   BorrowIncentiveAccountsQueryInterface,
   BorrowIncentiveAccounts,
-  SupportBorrowIncentiveCoins,
-  SupportBorrowIncentiveRewardCoins,
   BorrowIncentivePoolPoints,
   OptionalKeys,
-  BorrowIncentivePool,
   CoinPrices,
   MarketPools,
 } from '../types';
@@ -56,9 +49,7 @@ export const queryBorrowIncentivePools = async (address: ScallopAddress) => {
  */
 export const getBorrowIncentivePools = async (
   query: ScallopQuery,
-  borrowIncentiveCoinNames: SupportBorrowIncentiveCoins[] = [
-    ...SUPPORT_BORROW_INCENTIVE_POOLS,
-  ],
+  borrowIncentiveCoinNames: string[] = [...query.constants.whitelist.lending],
   indexer: boolean = false,
   marketPools?: MarketPools,
   coinPrices?: CoinPrices
@@ -69,36 +60,13 @@ export const getBorrowIncentivePools = async (
     (await query.getMarketPools(undefined, { coinPrices, indexer })).pools;
   coinPrices = coinPrices ?? (await query.getAllCoinPrices({ marketPools }));
 
-  if (indexer) {
-    const borrowIncentivePoolsIndexer =
-      await query.indexer.getBorrowIncentivePools();
-
-    const updateBorrowIncentivePool = (pool: BorrowIncentivePool) => {
-      if (!borrowIncentiveCoinNames.includes(pool.coinName)) return;
-      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;
-    };
-
-    Object.values(borrowIncentivePoolsIndexer).forEach(
-      updateBorrowIncentivePool
-    );
-
-    return borrowIncentivePools;
-  }
-
   const borrowIncentivePoolsQueryData = await queryBorrowIncentivePools(
     query.address
   );
 
   for (const pool of borrowIncentivePoolsQueryData?.incentive_pools ?? []) {
     const borrowIncentivePoolPoints: OptionalKeys<
-      Record<SupportBorrowIncentiveRewardCoins, BorrowIncentivePoolPoints>
+      Record<string, BorrowIncentivePoolPoints>
     > = {};
     const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(
       query.utils,
@@ -106,10 +74,7 @@ export const getBorrowIncentivePools = async (
     );
 
     const poolCoinType = normalizeStructTag(pool.pool_type.name);
-    const poolCoinName =
-      query.utils.parseCoinNameFromType<SupportBorrowIncentiveCoins>(
-        poolCoinType
-      );
+    const poolCoinName = query.utils.parseCoinNameFromType(poolCoinType);
     const poolCoinPrice = coinPrices?.[poolCoinName] ?? 0;
     const poolCoinDecimal = query.utils.getCoinDecimal(poolCoinName);
 
@@ -122,12 +87,16 @@ export const getBorrowIncentivePools = async (
     for (const [coinName, poolPoint] of Object.entries(
       parsedBorrowIncentivePoolData.poolPoints
     )) {
+      if (!poolPoint) continue;
       const rewardCoinType = poolPoint.pointType;
       const rewardCoinName = query.utils.parseCoinNameFromType(
         rewardCoinType
-      ) as SupportBorrowIncentiveRewardCoins;
+      ) as string;
       // handle for scoin name
       const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+      if (rewardCoinDecimal === undefined)
+        throw new Error(`Coin decimal not found for ${rewardCoinName}`);
+
       const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
 
       const symbol = query.utils.parseSymbol(rewardCoinName);
@@ -142,18 +111,17 @@ export const getBorrowIncentivePools = async (
         poolCoinDecimal
       );
 
-      borrowIncentivePoolPoints[coinName as SupportBorrowIncentiveRewardCoins] =
-        {
-          symbol,
-          coinName: rewardCoinName,
-          coinType: rewardCoinType,
-          coinDecimal,
-          coinPrice: rewardCoinPrice,
-          points: poolPoint.points,
-          distributedPoint: poolPoint.distributedPoint,
-          weightedAmount: poolPoint.weightedAmount,
-          ...calculatedPoolPoint,
-        };
+      borrowIncentivePoolPoints[coinName as string] = {
+        symbol,
+        coinName: rewardCoinName,
+        coinType: rewardCoinType,
+        coinDecimal,
+        coinPrice: rewardCoinPrice,
+        points: poolPoint.points,
+        distributedPoint: poolPoint.distributedPoint,
+        weightedAmount: poolPoint.weightedAmount,
+        ...calculatedPoolPoint,
+      };
     }
 
     const stakedAmount = BigNumber(parsedBorrowIncentivePoolData.staked);
@@ -190,9 +158,7 @@ export const queryBorrowIncentiveAccounts = async (
     utils: ScallopUtils;
   },
   obligationId: string | SuiObjectRef,
-  borrowIncentiveCoinNames: SupportBorrowIncentiveCoins[] = [
-    ...SUPPORT_BORROW_INCENTIVE_POOLS,
-  ]
+  borrowIncentiveCoinNames: string[] = [...utils.constants.whitelist.lending]
 ) => {
   const queryPkgId = utils.address.get('borrowIncentive.query');
   const incentiveAccountsId = utils.address.get(
@@ -211,8 +177,7 @@ export const queryBorrowIncentiveAccounts = async (
     const parsedBorrowIncentiveAccount =
       parseOriginBorrowIncentiveAccountData(accountData);
     const poolType = parsedBorrowIncentiveAccount.poolType;
-    const coinName =
-      utils.parseCoinNameFromType<SupportBorrowIncentiveCoins>(poolType);
+    const coinName = utils.parseCoinNameFromType(poolType);
 
     if (
       borrowIncentiveCoinNames &&