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

package/src/queries/poolAddressesQuery.ts

@@ -1,59 +1,118 @@
-import { PYTH_FEED_IDS } from 'src/constants';
-import { ScallopQuery } from 'src/models';
-import { OptionalKeys, SupportPoolCoins } from 'src/types';
+import { getFullnodeUrl, SuiClient } from '@mysten/sui/client';
+import { AddressesInterface, OptionalKeys, PoolAddress } from 'src/types';
 
-export const getAllAddresses = async (
-  query: ScallopQuery,
-  pools: SupportPoolCoins[]
+const RPC_PROVIDERS = [
+  getFullnodeUrl('mainnet'),
+  'https://sui-mainnet.public.blastapi.io',
+  'https://sui-mainnet-ca-2.cosmostation.io',
+  'https://sui-mainnet-eu-4.cosmostation.io',
+  'https://sui-mainnet-endpoint.blockvision.org',
+  'https://sui-rpc.publicnode.com',
+  'https://sui-mainnet-rpc.allthatnode.com',
+  'https://mainnet.suiet.app',
+  'https://mainnet.sui.rpcpool.com',
+  'https://sui1mainnet-rpc.chainode.tech',
+  'https://fullnode.mainnet.apis.scallop.io',
+  'https://sui-mainnet-us-2.cosmostation.io',
+];
+
+const tryRequest = async <T>(fn: (client: SuiClient) => T) => {
+  for (const rpc of RPC_PROVIDERS) {
+    try {
+      const res = await fn(new SuiClient({ url: rpc }));
+      return res;
+    } catch (e: any) {
+      if (e.status !== 429) {
+        throw e;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+  }
+  throw new Error('Failed to fetch data');
+};
+
+const queryFlashloanFeeObjectIds = async (
+  client: SuiClient,
+  coinTypeMap: Set<string>, // set of coin types
+  flashloanFeeTableId: string = '0x00481a93b819d744a7d79ecdc6c62c74f2f7cb4779316c4df640415817ac61bb'
 ) => {
-  const results: OptionalKeys<
-    Record<
-      SupportPoolCoins,
-      {
-        coinName: string;
-        symbol: string;
-        lendingPoolAddress?: string;
-        collateralPoolAddress?: string; // not all pool has collateral
-        borrowDynamic?: string;
-        spoolReward?: string;
-        spool?: string;
-        sCoinType?: string;
-        sCoinName?: string;
-        sCoinSymbol?: string;
-        sCoinTreasury?: string;
-        interestModel?: string;
-        riskModel?: string;
-        borrowFeeKey?: string;
-        supplyLimitKey?: string;
-        borrowLimitKey?: string;
-        isolatedAssetKey?: string;
-        coinMetadataId?: string;
-        borrowIncentivePoolId?: string;
-        coinType?: string;
-        sCoinMetadataId?: string;
-        spoolName?: string;
-        decimals: number;
-        pythFeed?: string;
-        pythFeedObjectId?: string;
+  let cursor: string | null | undefined = null;
+  let nextPage: boolean = false;
+  const flashloanFeeObjectIds: Record<string, string> = {}; // <coinType, flashloanFeeObjectId>
+
+  do {
+    const resp = await client.getDynamicFields({
+      parentId: flashloanFeeTableId,
+      limit: 10,
+      cursor,
+    });
+    if (!resp) break;
+    const { data, hasNextPage, nextCursor } = resp;
+    // get the dynamic object ids
+    data.forEach((field) => {
+      const assetType = `0x${(field.name.value as any).name as string}`;
+      if (coinTypeMap.has(assetType)) {
+        flashloanFeeObjectIds[assetType] = field.objectId;
       }
-    >
-  > = {};
+    });
+    nextPage = hasNextPage;
+    cursor = nextCursor;
+  } while (nextPage);
+
+  return flashloanFeeObjectIds;
+};
 
-  const marketId = query.address.get('core.market');
-  const marketObject = (await query.cache.queryGetObject(marketId))?.data;
+export const getPoolAddresses = async (
+  addressId: string,
+  poolNames: string[] = []
+) => {
+  const poolNameSet = new Set(poolNames);
+  const results: OptionalKeys<Record<string, PoolAddress>> = {};
 
-  if (!(marketObject && marketObject.content?.dataType === 'moveObject'))
-    throw new Error(`Failed to fetch marketObject`);
+  // fetch the Address API
+  const URL = 'https://sui.apis.scallop.io';
+  const addressApiResponse = (
+    await fetch(`${URL}/addresses/${addressId}`).then((res) => res.json())
+  ).mainnet as unknown as AddressesInterface;
 
-  const fields = marketObject.content.fields as any;
+  if (!addressApiResponse) throw new Error('Failed to fetch addresses');
+
+  // Compose pools based on addresses
+  const pools = Object.keys(addressApiResponse.core.coins);
+  if (pools.length === 0) throw new Error('Pools empty');
 
   const coinTypesPairs = pools.reduce(
-    (acc, pool) => {
-      acc.push([pool, query.utils.parseCoinType(pool).substring(2)]);
+    (acc, poolName) => {
+      if (poolNameSet.size > 0 && !poolNameSet.has(poolName)) return acc;
+      const value =
+        addressApiResponse.core.coins[
+          poolName as keyof typeof addressApiResponse.core.coins
+        ];
+      if (value && value.coinType) {
+        acc.push([poolName, value.coinType]);
+      }
       return acc;
     },
-    [] as [SupportPoolCoins, string][]
+    [] as [string, string][]
   );
+  if (coinTypesPairs.length === 0) throw new Error('No coinTypesPairs');
+
+  const marketId = addressApiResponse.core.market;
+  const marketObject = (
+    await tryRequest(async (client) => {
+      return await client.getObject({
+        id: marketId,
+        options: {
+          showContent: true,
+        },
+      });
+    })
+  ).data;
+
+  if (!(marketObject && marketObject.content?.dataType === 'moveObject'))
+    throw new Error(`Failed to fetch marketObject`);
+
+  const fields = marketObject.content.fields as any;
 
   const balanceSheetParentId =
     fields.vault.fields.balance_sheets.fields.table.fields.id.id;
@@ -79,111 +138,127 @@ export const getAllAddresses = async (
     type: string,
     value: any
   ) => {
-    try {
-      return (
-        await query.cache.queryGetDynamicFieldObject({
+    return (
+      await tryRequest(async (client) => {
+        return await client.getDynamicFieldObject({
           parentId,
           name: {
             type,
             value,
           },
-        })
-      )?.data?.objectId;
-    } catch (e: any) {
-      console.error(e.message);
-      return undefined;
-    }
+        });
+      })
+    ).data?.objectId;
   };
 
+  // query flashloan fee objects first
+  const flashloanFeeObjectIds = await tryRequest(async (client) => {
+    return await queryFlashloanFeeObjectIds(
+      client,
+      new Set(coinTypesPairs.map(([, coinType]) => coinType))
+    );
+  });
+
   await Promise.all(
     coinTypesPairs.map(async ([coinName, coinType]) => {
+      const coinTypeKey = coinType.slice(2);
       const addresses = await Promise.all([
         fetchDynamicObject(balanceSheetParentId, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
         fetchDynamicObject(collateralStatsParentId, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
         fetchDynamicObject(borrowDynamicsParentid, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
         fetchDynamicObject(interestModelParentId, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
         fetchDynamicObject(riskModelParentId, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
-        fetchDynamicObject(marketId, BORROW_FEE_TYPE, coinType),
-        fetchDynamicObject(marketId, SUPPLY_LIMIT_TYPE, coinType),
-        fetchDynamicObject(marketId, BORROW_LIMIT_TYPE, coinType),
-        fetchDynamicObject(marketId, ISOLATED_ASSET_KEY, coinType),
+        fetchDynamicObject(marketId, BORROW_FEE_TYPE, coinTypeKey),
+        fetchDynamicObject(marketId, SUPPLY_LIMIT_TYPE, coinTypeKey),
+        fetchDynamicObject(marketId, BORROW_LIMIT_TYPE, coinTypeKey),
+        fetchDynamicObject(marketId, ISOLATED_ASSET_KEY, coinTypeKey),
       ]);
 
-      const spool = query.address.get(
-        // @ts-ignore
-        `spool.pools.s${coinName}.id`
-      );
-      const rewardPool = query.address.get(
-        // @ts-ignore
-        `spool.pools.s${coinName}.rewardPoolId`
-      );
-      const sCoinType = query.address.get(
-        // @ts-ignore
-        `scoin.coins.s${coinName}.coinType`
-      );
-      const sCoinName = sCoinType
-        ? query.utils.parseSCoinName(coinName)
-        : undefined;
-      const sCoinSymbol = sCoinName
-        ? query.utils.parseSymbol(sCoinName)
-        : undefined;
-      const sCoinTreasury = query.address.get(
-        // @ts-ignore
-        `scoin.coins.s${coinName}.treasury`
-      );
-      const coinMetadataId = query.address.get(
-        `core.coins.${coinName}.metaData`
-      );
-      const sCoinMetadataId = query.address.get(
+      // @ts-ignore
+      const { symbol, metaData: coinMetadataId } =
+        addressApiResponse.core.coins[coinName];
+
+      let spoolData = undefined;
+      const _spoolData = addressApiResponse.spool.pools[`s${coinName}`];
+      // @ts-ignore
+      if (_spoolData) {
         // @ts-ignore
-        `scoin.coins.s${coinName}.metaData`
-      );
+        const { id: spool, rewardPoolId: spoolReward } = _spoolData;
+        spoolData = {
+          spool,
+          spoolReward,
+          coinMetadataId,
+        };
+      }
 
-      const pythFeed = PYTH_FEED_IDS[coinName];
-      const pythFeedObjectId = query.address.get(
+      let sCoinData = undefined;
+      const sCoinName = `s${coinName}`;
+      const _sCoinData = addressApiResponse.scoin.coins[sCoinName];
+      if (_sCoinData) {
+        const {
+          coinType: sCoinType,
+          treasury: sCoinTreasury,
+          metaData: sCoinMetadataId,
+          symbol: sCoinSymbol,
+        } = _sCoinData;
+        sCoinData = {
+          sCoinType,
+          sCoinTreasury,
+          sCoinMetadataId,
+          sCoinSymbol,
+        };
+      }
+
+      const { feed: pythFeed, feedObject: pythFeedObjectId } =
         //@ts-ignore
-        `core.coins.${coinName}.oracle.pyth.feedObject`
-      );
-      const decimals = query.utils.getCoinDecimal(coinName);
-      const spoolName = spool ? `s${coinName}` : undefined;
-      results[coinName as SupportPoolCoins] = {
+        addressApiResponse.core.coins[coinName].oracle.pyth;
+
+      const decimals =
+        (
+          await tryRequest(async (client) => {
+            return await client.getCoinMetadata({
+              coinType: coinType,
+            });
+          })
+        )?.decimals ?? 0;
+      const spoolName = spoolData ? `s${coinName}` : undefined;
+
+      // @TODO: add query for flashloanFeeObject
+      results[coinName] = {
         coinName,
-        symbol: query.utils.parseSymbol(coinName),
-        lendingPoolAddress: addresses[0],
-        collateralPoolAddress: addresses[1],
-        borrowDynamic: addresses[2],
-        interestModel: addresses[3],
+        symbol,
+        lendingPoolAddress: addresses[0] ?? '',
+        collateralPoolAddress: addresses[1] ?? '',
+        borrowDynamic: addresses[2] ?? '',
+        interestModel: addresses[3] ?? '',
         riskModel: addresses[4],
-        borrowFeeKey: addresses[5],
+        borrowFeeKey: addresses[5] ?? '',
         supplyLimitKey: addresses[6],
         borrowLimitKey: addresses[7],
         isolatedAssetKey: addresses[8],
-        spool,
-        spoolReward: rewardPool,
-        sCoinTreasury,
-        sCoinType,
+        ...(spoolData ?? {}),
+        ...(sCoinData ?? {}),
         sCoinName,
-        sCoinSymbol,
         coinMetadataId,
-        coinType: `0x${coinType}`,
-        sCoinMetadataId,
+        coinType,
         spoolName,
         decimals,
         pythFeed,
         pythFeedObjectId,
+        flashloanFeeObject: flashloanFeeObjectIds[coinType] ?? '',
       };
 
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      await new Promise((resolve) => setTimeout(resolve, 1000));
     })
   );
 

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] = {