@scallop-io/sui-scallop-sdk 0.44.6 → 0.44.8

package/src/queries/coreQuery.ts

@@ -45,10 +45,13 @@ import {
  * Use inspectTxn call to obtain the data provided in the scallop contract query module.
  *
  * @param query - The Scallop query instance.
- * @param rateType - How interest rates are calculated.
+ * @param indexer - Whether to use indexer.
  * @return Market data.
  */
-export const queryMarket = async (query: ScallopQuery) => {
+export const queryMarket = async (
+  query: ScallopQuery,
+  indexer: boolean = false
+) => {
   const packageId = query.address.get('core.packages.query.id');
   const marketId = query.address.get('core.market');
   const txBlock = new SuiKitTxBlock();
@@ -56,16 +59,35 @@ export const queryMarket = async (query: ScallopQuery) => {
   txBlock.moveCall(queryTarget, [marketId]);
   const queryResult = await query.suiKit.inspectTxn(txBlock);
   const marketData = queryResult.events[0].parsedJson as MarketQueryInterface;
+  const coinPrices = await query.utils.getCoinPrices();
 
   const pools: MarketPools = {};
   const collaterals: MarketCollaterals = {};
 
+  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
+      );
+    }
+    return {
+      pools: marketIndexer.pools,
+      collaterals: marketIndexer.collaterals,
+    };
+  }
+
   for (const pool of marketData.pools) {
     const coinType = normalizeStructTag(pool.type.name);
     const poolCoinName =
       query.utils.parseCoinNameFromType<SupportPoolCoins>(coinType);
-    const coinPrice =
-      (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
+    const coinPrice = coinPrices[poolCoinName] ?? 0;
 
     // Filter pools not yet supported by the SDK.
     if (!SUPPORT_POOLS.includes(poolCoinName)) {
@@ -122,10 +144,7 @@ export const queryMarket = async (query: ScallopQuery) => {
     const coinType = normalizeStructTag(collateral.type.name);
     const collateralCoinName =
       query.utils.parseCoinNameFromType<SupportCollateralCoins>(coinType);
-    const coinPrice =
-      (await query.utils.getCoinPrices([collateralCoinName]))?.[
-        collateralCoinName
-      ] ?? 0;
+    const coinPrice = coinPrices[collateralCoinName] ?? 0;
 
     // Filter collaterals not yet supported by the SDK.
     if (!SUPPORT_COLLATERALS.includes(collateralCoinName)) {
@@ -182,11 +201,13 @@ export const queryMarket = async (query: ScallopQuery) => {
  *
  * @param query - The Scallop query instance.
  * @param coinNames - Specific an array of support pool coin name.
+ * @param indexer - Whether to use indexer.
  * @return Market pools data.
  */
 export const getMarketPools = async (
   query: ScallopQuery,
-  poolCoinNames?: SupportPoolCoins[]
+  poolCoinNames?: SupportPoolCoins[],
+  indexer: boolean = false
 ) => {
   poolCoinNames = poolCoinNames || [...SUPPORT_POOLS];
   const marketId = query.address.get('core.market');
@@ -199,10 +220,27 @@ export const getMarketPools = async (
   const coinPrices = await query.utils.getCoinPrices(poolCoinNames ?? []);
 
   const marketPools: MarketPools = {};
+
+  if (indexer) {
+    const marketPoolsIndexer = await query.indexer.getMarketPools();
+    for (const marketPool of Object.values(marketPoolsIndexer)) {
+      if (!poolCoinNames.includes(marketPool.coinName)) continue;
+      marketPool.coinPrice =
+        coinPrices[marketPool.coinName] || marketPool.coinPrice;
+      marketPool.coinWrappedType = query.utils.getCoinWrappedType(
+        marketPool.coinName
+      );
+      marketPools[marketPool.coinName] = marketPool;
+    }
+
+    return marketPools;
+  }
+
   for (const poolCoinName of poolCoinNames) {
     const marketPool = await getMarketPool(
       query,
       poolCoinName,
+      indexer,
       marketObjectResponse.data,
       coinPrices?.[poolCoinName]
     );
@@ -220,6 +258,7 @@ export const getMarketPools = async (
  *
  * @param query - The Scallop query instance.
  * @param poolCoinName - Specific support pool coin name.
+ * @param indexer - Whether to use indexer.
  * @param marketObject - The market object.
  * @param coinPrice - The coin price.
  * @returns Market pool data.
@@ -227,6 +266,7 @@ export const getMarketPools = async (
 export const getMarketPool = async (
   query: ScallopQuery,
   poolCoinName: SupportPoolCoins,
+  indexer: boolean = false,
   marketObject?: SuiObjectData | null,
   coinPrice?: number
 ) => {
@@ -242,11 +282,26 @@ export const getMarketPool = async (
       })
     ).data;
 
+  coinPrice =
+    coinPrice ||
+    (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
+
   let marketPool: MarketPool | undefined;
   let balanceSheet: BalanceSheet | undefined;
   let borrowIndex: BorrowIndex | undefined;
   let interestModel: InterestModel | undefined;
   let borrowFeeRate: { value: string } | undefined;
+
+  if (indexer) {
+    const marketPoolIndexer = await query.indexer.getMarketPool(poolCoinName);
+    marketPoolIndexer.coinPrice = coinPrice || marketPoolIndexer.coinPrice;
+    marketPoolIndexer.coinWrappedType = query.utils.getCoinWrappedType(
+      marketPoolIndexer.coinName
+    );
+
+    return marketPoolIndexer;
+  }
+
   if (marketObject) {
     if (marketObject.content && 'fields' in marketObject.content) {
       const fields = marketObject.content.fields as any;
@@ -386,9 +441,6 @@ export const getMarketPool = async (
       parsedMarketPoolData
     );
 
-    coinPrice =
-      coinPrice ||
-      (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
     marketPool = {
       coinName: poolCoinName,
       symbol: query.utils.parseSymbol(poolCoinName),
@@ -420,11 +472,13 @@ export const getMarketPool = async (
  *
  * @param query - The Scallop query instance.
  * @param collateralCoinNames - Specific an array of support collateral coin name.
+ * @param indexer - Whether to use indexer.
  * @return Market collaterals data.
  */
 export const getMarketCollaterals = async (
   query: ScallopQuery,
-  collateralCoinNames?: SupportCollateralCoins[]
+  collateralCoinNames?: SupportCollateralCoins[],
+  indexer: boolean = false
 ) => {
   collateralCoinNames = collateralCoinNames || [...SUPPORT_COLLATERALS];
   const marketId = query.address.get('core.market');
@@ -437,10 +491,26 @@ export const getMarketCollaterals = async (
   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;
+      marketCollateral.coinPrice =
+        coinPrices[marketCollateral.coinName] || marketCollateral.coinPrice;
+      marketCollateral.coinWrappedType = query.utils.getCoinWrappedType(
+        marketCollateral.coinName
+      );
+      marketCollaterals[marketCollateral.coinName] = marketCollateral;
+    }
+    return marketCollaterals;
+  }
+
   for (const collateralCoinName of collateralCoinNames) {
     const marketCollateral = await getMarketCollateral(
       query,
       collateralCoinName,
+      indexer,
       marketObjectResponse.data,
       coinPrices?.[collateralCoinName]
     );
@@ -458,6 +528,7 @@ export const getMarketCollaterals = async (
  *
  * @param query - The Scallop query instance.
  * @param collateralCoinName - Specific support collateral coin name.
+ * @param indexer - Whether to use indexer.
  * @param marketObject - The market object.
  * @param coinPrice - The coin price.
  * @returns Market collateral data.
@@ -465,6 +536,7 @@ export const getMarketCollaterals = async (
 export const getMarketCollateral = async (
   query: ScallopQuery,
   collateralCoinName: SupportCollateralCoins,
+  indexer: boolean = false,
   marketObject?: SuiObjectData | null,
   coinPrice?: number
 ) => {
@@ -480,9 +552,28 @@ export const getMarketCollateral = async (
       })
     ).data;
 
+  coinPrice =
+    coinPrice ||
+    (await query.utils.getCoinPrices([collateralCoinName]))?.[
+      collateralCoinName
+    ];
+
   let marketCollateral: MarketCollateral | undefined;
   let riskModel: RiskModel | undefined;
   let collateralStat: CollateralStat | undefined;
+
+  if (indexer) {
+    const marketCollateralIndexer =
+      await query.indexer.getMarketCollateral(collateralCoinName);
+    marketCollateralIndexer.coinPrice =
+      coinPrice || marketCollateralIndexer.coinPrice;
+    marketCollateralIndexer.coinWrappedType = query.utils.getCoinWrappedType(
+      marketCollateralIndexer.coinName
+    );
+
+    return marketCollateralIndexer;
+  }
+
   if (marketObject) {
     if (marketObject.content && 'fields' in marketObject.content) {
       const fields = marketObject.content.fields as any;
@@ -558,11 +649,6 @@ export const getMarketCollateral = async (
       parsedMarketCollateralData
     );
 
-    coinPrice =
-      coinPrice ||
-      (await query.utils.getCoinPrices([collateralCoinName]))?.[
-        collateralCoinName
-      ];
     marketCollateral = {
       coinName: collateralCoinName,
       symbol: query.utils.parseSymbol(collateralCoinName),

package/src/queries/portfolioQuery.ts

@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
 import { SUPPORT_POOLS, SUPPORT_SPOOLS } from '../constants';
-import { minBigNumber } from 'src/utils';
+import { minBigNumber, estimatedFactor } from 'src/utils';
 import type { ScallopQuery } from '../models';
 import type {
   Market,
@@ -28,12 +28,14 @@ import type {
  * @param query - The ScallopQuery instance.
  * @param poolCoinNames - Specific an array of support pool coin name.
  * @param ownerAddress - The owner address.
+ * @param indexer - Whether to use indexer.
  * @return User lending infomation for specific pools.
  */
 export const getLendings = async (
   query: ScallopQuery,
   poolCoinNames?: SupportPoolCoins[],
-  ownerAddress?: string
+  ownerAddress?: string,
+  indexer: boolean = false
 ) => {
   poolCoinNames = poolCoinNames || [...SUPPORT_POOLS];
   const marketCoinNames = poolCoinNames.map((poolCoinName) =>
@@ -43,8 +45,8 @@ export const getLendings = async (
     (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName)
   ) as SupportStakeMarketCoins[];
 
-  const marketPools = await query.getMarketPools(poolCoinNames);
-  const spools = await query.getSpools(stakeMarketCoinNames);
+  const marketPools = await query.getMarketPools(poolCoinNames, indexer);
+  const spools = await query.getSpools(stakeMarketCoinNames, indexer);
   const coinAmounts = await query.getCoinAmounts(poolCoinNames, ownerAddress);
   const marketCoinAmounts = await query.getMarketCoinAmounts(
     marketCoinNames,
@@ -64,6 +66,7 @@ export const getLendings = async (
       query,
       poolCoinName,
       ownerAddress,
+      indexer,
       marketPools?.[poolCoinName],
       stakeMarketCoinName ? spools[stakeMarketCoinName] : undefined,
       stakeMarketCoinName ? allStakeAccounts[stakeMarketCoinName] : undefined,
@@ -85,6 +88,7 @@ export const getLendings = async (
  * @param query - The ScallopQuery instance.
  * @param poolCoinName - Specific support coin name.
  * @param ownerAddress - The owner address.
+ * @param indexer - Whether to use indexer.
  * @param marketPool - The market pool data.
  * @param spool - The spool data.
  * @param stakeAccounts - The stake accounts data.
@@ -96,6 +100,7 @@ export const getLending = async (
   query: ScallopQuery,
   poolCoinName: SupportPoolCoins,
   ownerAddress?: string,
+  indexer: boolean = false,
   marketPool?: MarketPool,
   spool?: Spool,
   stakeAccounts?: StakeAccount[],
@@ -104,11 +109,11 @@ export const getLending = async (
   coinPrice?: number
 ) => {
   const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
-  marketPool = marketPool || (await query.getMarketPool(poolCoinName));
+  marketPool = marketPool || (await query.getMarketPool(poolCoinName, indexer));
   spool =
     spool ||
     (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName)
-      ? await query.getSpool(marketCoinName as SupportStakeMarketCoins)
+      ? await query.getSpool(marketCoinName as SupportStakeMarketCoins, indexer)
       : undefined;
   stakeAccounts =
     stakeAccounts ||
@@ -170,7 +175,7 @@ export const getLending = async (
       );
 
       const baseIndexRate = 1_000_000_000;
-      const increasedPointRate = spool?.currentPointIndex
+      const increasedPointRate = spool.currentPointIndex
         ? BigNumber(spool.currentPointIndex - stakeAccount.index).dividedBy(
             baseIndexRate
           )
@@ -252,13 +257,15 @@ export const getLending = async (
  *
  * @param query - The Scallop query instance.
  * @param ownerAddress - The owner address.
+ * @param indexer - Whether to use indexer.
  * @return All obligation accounts data.
  */
 export const getObligationAccounts = async (
   query: ScallopQuery,
-  ownerAddress?: string
+  ownerAddress?: string,
+  indexer: boolean = false
 ) => {
-  const market = await query.queryMarket();
+  const market = await query.queryMarket(indexer);
   const coinPrices = await query.utils.getCoinPrices();
   const coinAmounts = await query.getCoinAmounts(undefined, ownerAddress);
   const obligations = await query.getObligations(ownerAddress);
@@ -269,6 +276,7 @@ export const getObligationAccounts = async (
       query,
       obligation.id,
       ownerAddress,
+      indexer,
       market,
       coinPrices,
       coinAmounts
@@ -283,17 +291,19 @@ export const getObligationAccounts = async (
  *
  * @param query - The Scallop query instance.
  * @param obligationId - The obligation id.
+ * @param indexer - Whether to use indexer.
  * @return Obligation account data.
  */
 export const getObligationAccount = async (
   query: ScallopQuery,
   obligationId: string,
   ownerAddress?: string,
+  indexer: boolean = false,
   market?: Market,
   coinPrices?: CoinPrices,
   coinAmounts?: CoinAmounts
 ) => {
-  market = market || (await query.queryMarket());
+  market = market || (await query.queryMarket(indexer));
   const assetCoinNames: SupportAssetCoins[] = [
     ...new Set([
       ...Object.values(market.pools).map((pool) => pool.coinName),
@@ -303,7 +313,10 @@ export const getObligationAccount = async (
     ]),
   ];
   const obligationQuery = await query.queryObligation(obligationId);
-  const borrowIncentivePools = await query.getBorrowIncentivePools();
+  const borrowIncentivePools = await query.getBorrowIncentivePools(
+    undefined,
+    indexer
+  );
   const borrowIncentiveAccounts =
     await query.getBorrowIncentiveAccounts(obligationId);
   coinPrices = coinPrices || (await query.utils.getCoinPrices(assetCoinNames));
@@ -330,8 +343,8 @@ export const getObligationAccount = async (
       return assetCoinName === collateralCoinName;
     });
 
-    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const marketCollateral = market.collaterals[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const coinPrice = coinPrices?.[assetCoinName];
     const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
 
@@ -388,9 +401,10 @@ export const getObligationAccount = async (
       return assetCoinName === poolCoinName;
     });
 
-    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const marketPool = market.pools[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const coinPrice = coinPrices?.[assetCoinName];
+    const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
 
     if (marketPool && coinPrice) {
       const increasedRate = debt?.borrowIndex
@@ -398,13 +412,18 @@ export const getObligationAccount = async (
         : 0;
       const borrowedAmount = BigNumber(debt?.amount ?? 0);
       const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
-      const availableRepayAmount = borrowedAmount.multipliedBy(
+
+      const requiredRepayAmount = borrowedAmount.multipliedBy(
         increasedRate + 1
       );
+      const requiredRepayCoin = requiredRepayAmount.shiftedBy(-1 * coinDecimal);
+
+      const availableRepayAmount = BigNumber(coinAmount);
       const availableRepayCoin = availableRepayAmount.shiftedBy(
         -1 * coinDecimal
       );
-      const borrowedValue = availableRepayCoin.multipliedBy(coinPrice);
+
+      const borrowedValue = requiredRepayCoin.multipliedBy(coinPrice);
       const borrowedValueWithWeight = borrowedValue.multipliedBy(
         marketPool.borrowWeight
       );
@@ -429,6 +448,8 @@ export const getObligationAccount = async (
         borrowedValue: borrowedValue.toNumber(),
         borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
         borrowIndex: Number(debt?.borrowIndex ?? 0),
+        requiredRepayAmount: requiredRepayAmount.toNumber(),
+        requiredRepayCoin: requiredRepayCoin.toNumber(),
         availableBorrowAmount: 0,
         availableBorrowCoin: 0,
         availableRepayAmount: availableRepayAmount.toNumber(),
@@ -481,16 +502,11 @@ export const getObligationAccount = async (
     }
   }
 
-  let riskLevel =
-    totalRequiredCollateralValue.isZero() &&
-    totalBorrowedValueWithWeight.isZero()
-      ? BigNumber(0)
-      : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
-  riskLevel = riskLevel.isFinite()
-    ? riskLevel.isLessThan(1)
-      ? riskLevel
-      : BigNumber(1)
-    : BigNumber(1);
+  let riskLevel = totalRequiredCollateralValue.isZero()
+    ? BigNumber(0)
+    : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
+  // Note: 100% represents the safety upper limit. Even if it exceeds 100% before it is liquidated, it will only display 100%.
+  riskLevel = riskLevel.isLessThan(1) ? riskLevel : BigNumber(1);
 
   const accountBalanceValue = totalDepositedValue
     .minus(totalBorrowedValue)
@@ -543,24 +559,38 @@ export const getObligationAccount = async (
     const marketCollateral =
       market.collaterals[collateralCoinName as SupportCollateralCoins];
     if (marketCollateral) {
-      const availableWithdrawAmount =
+      let estimatedAvailableWithdrawAmount = BigNumber(
+        obligationAccount.totalAvailableCollateralValue
+      )
+        .dividedBy(marketCollateral.collateralFactor)
+        .dividedBy(marketCollateral.coinPrice)
+        .shiftedBy(marketCollateral.coinDecimal);
+      estimatedAvailableWithdrawAmount =
         obligationAccount.totalBorrowedValueWithWeight === 0
-          ? BigNumber(obligationCollateral.depositedAmount)
+          ? // Note: when there is no debt record, there is no need to estimate and the deposited amount is directly used as available withdraw.
+            BigNumber(obligationCollateral.depositedAmount)
           : minBigNumber(
-              BigNumber(obligationAccount.totalAvailableCollateralValue)
-                .dividedBy(marketCollateral.collateralFactor)
-                .dividedBy(marketCollateral.coinPrice)
+              estimatedAvailableWithdrawAmount
                 // Note: reduced chance of failure when calculations are inaccurate
-                .multipliedBy(0.99)
+                .multipliedBy(
+                  estimatedFactor(
+                    BigNumber(obligationAccount.totalAvailableCollateralValue)
+                      .dividedBy(marketCollateral.collateralFactor)
+                      .toNumber(),
+                    3,
+                    'increase'
+                  )
+                )
                 .toNumber(),
               obligationCollateral.depositedAmount,
               marketCollateral.depositAmount
             );
       obligationCollateral.availableWithdrawAmount =
-        availableWithdrawAmount.toNumber();
-      obligationCollateral.availableWithdrawCoin = availableWithdrawAmount
-        .shiftedBy(-1 * obligationCollateral.coinDecimal)
-        .toNumber();
+        estimatedAvailableWithdrawAmount.toNumber();
+      obligationCollateral.availableWithdrawCoin =
+        estimatedAvailableWithdrawAmount
+          .shiftedBy(-1 * obligationCollateral.coinDecimal)
+          .toNumber();
     }
   }
   for (const [poolCoinName, obligationDebt] of Object.entries(
@@ -568,33 +598,49 @@ export const getObligationAccount = async (
   )) {
     const marketPool = market.pools[poolCoinName as SupportPoolCoins];
     if (marketPool) {
-      const availableRepayAmount = BigNumber(
-        obligationDebt.availableRepayAmount
+      const estimatedRequiredRepayAmount = BigNumber(
+        obligationDebt.requiredRepayAmount
       )
-        // Note: reduced chance of failure when calculations are inaccurate
-        .multipliedBy(1.01);
+        // Note: reduced chance of not being able to repay in full when calculations are inaccurate,
+        // and the contract will not actually take the excess amount.
+        .multipliedBy(
+          estimatedFactor(obligationDebt.borrowedValue, 3, 'decrease')
+        );
 
-      const availableBorrowAmount =
+      let estimatedAvailableBorrowAmount = BigNumber(
+        obligationAccount.totalAvailableCollateralValue
+      )
+        .dividedBy(marketPool.borrowWeight)
+        .shiftedBy(marketPool.coinDecimal)
+        .dividedBy(marketPool.coinPrice);
+      estimatedAvailableBorrowAmount =
         obligationAccount.totalAvailableCollateralValue !== 0
           ? minBigNumber(
-              BigNumber(obligationAccount.totalAvailableCollateralValue)
-                .dividedBy(
-                  BigNumber(marketPool.coinPrice).multipliedBy(
-                    marketPool.borrowWeight
+              estimatedAvailableBorrowAmount
+                // Note: reduced chance of failure when calculations are inaccurate
+                .multipliedBy(
+                  estimatedFactor(
+                    estimatedAvailableBorrowAmount
+                      .shiftedBy(-1 * marketPool.coinDecimal)
+                      .multipliedBy(marketPool.coinPrice)
+                      .toNumber(),
+                    3,
+                    'increase'
                   )
                 )
-                // Note: reduced chance of failure when calculations are inaccurate
-                .multipliedBy(0.99)
                 .toNumber(),
               marketPool.supplyAmount
             )
           : BigNumber(0);
-      obligationDebt.availableBorrowAmount = availableBorrowAmount.toNumber();
-      obligationDebt.availableBorrowCoin = availableBorrowAmount
+
+      obligationDebt.availableBorrowAmount =
+        estimatedAvailableBorrowAmount.toNumber();
+      obligationDebt.availableBorrowCoin = estimatedAvailableBorrowAmount
         .shiftedBy(-1 * obligationDebt.coinDecimal)
         .toNumber();
-      obligationDebt.availableRepayAmount = availableRepayAmount.toNumber();
-      obligationDebt.availableRepayCoin = availableRepayAmount
+      obligationDebt.requiredRepayAmount =
+        estimatedRequiredRepayAmount.toNumber();
+      obligationDebt.requiredRepayCoin = estimatedRequiredRepayAmount
         .shiftedBy(-1 * obligationDebt.coinDecimal)
         .toNumber();
     }
@@ -607,14 +653,27 @@ export const getObligationAccount = async (
  * Get total value locked data.
  *
  * @param query - The Scallop query instance.
+ * @param indexer - Whether to use indexer.
  * @return Total value locked data.
  */
-export const getTotalValueLocked = async (query: ScallopQuery) => {
-  const market = await query.queryMarket();
+export const getTotalValueLocked = async (
+  query: ScallopQuery,
+  indexer: boolean = false
+) => {
+  const market = await query.queryMarket(indexer);
 
   let supplyValue = BigNumber(0);
   let borrowValue = BigNumber(0);
 
+  if (indexer) {
+    const tvl = await query.indexer.getTotalValueLocked();
+    return {
+      supplyValue: tvl.supplyValue,
+      borrowValue: tvl.borrowValue,
+      totalValue: tvl.totalValue,
+    };
+  }
+
   for (const pool of Object.values(market.pools)) {
     supplyValue = supplyValue.plus(
       BigNumber(pool.supplyCoin).multipliedBy(pool.coinPrice)