@scallop-io/sui-scallop-sdk 0.44.7 → 0.44.9

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

@@ -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));
@@ -345,7 +358,14 @@ export const getObligationAccount = async (
       const requiredCollateralValue = depositedValue.multipliedBy(
         marketCollateral.liquidationFactor
       );
-      const availableDepositAmount = BigNumber(coinAmount);
+
+      const poolSizeAmount = BigNumber(marketCollateral.maxDepositAmount).minus(
+        marketCollateral.depositAmount
+      );
+      const availableDepositAmount = minBigNumber(
+        BigNumber(coinAmount),
+        poolSizeAmount
+      );
       const availableDepositCoin = availableDepositAmount.shiftedBy(
         -1 * coinDecimal
       );
@@ -640,14 +660,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)

package/src/queries/spoolQuery.ts

@@ -18,6 +18,7 @@ import type {
   StakeAccounts,
   SupportStakeMarketCoins,
   SupportStakeCoins,
+  CoinPrices,
 } from '../types';
 
 /**
@@ -25,25 +26,62 @@ import type {
  *
  * @param query - The Scallop query instance.
  * @param marketCoinNames - Specific an array of support stake market coin name.
+ * @param indexer - Whether to use indexer.
  * @return Spools data.
  */
 export const getSpools = async (
   query: ScallopQuery,
-  stakeMarketCoinNames?: SupportStakeMarketCoins[]
+  stakeMarketCoinNames?: SupportStakeMarketCoins[],
+  indexer: boolean = false
 ) => {
   stakeMarketCoinNames = stakeMarketCoinNames || [...SUPPORT_SPOOLS];
   const stakeCoinNames = stakeMarketCoinNames.map((stakeMarketCoinName) =>
     query.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName)
   );
-  const marketPool = await query.getMarketPools(stakeCoinNames);
+  const rewardCoinNames = stakeMarketCoinNames.map((stakeMarketCoinName) => {
+    const rewardCoinName =
+      query.utils.getSpoolRewardCoinName(stakeMarketCoinName);
+    return rewardCoinName;
+  });
+  const coinPrices = await query.utils.getCoinPrices(
+    [...new Set([...stakeCoinNames, ...rewardCoinNames])] ?? []
+  );
+
+  const marketPools = await query.getMarketPools(stakeCoinNames, indexer);
   const spools: Spools = {};
+
+  if (indexer) {
+    const spoolsIndexer = await query.indexer.getSpools();
+    for (const spool of Object.values(spoolsIndexer)) {
+      if (!stakeMarketCoinNames.includes(spool.marketCoinName)) continue;
+      const coinName = query.utils.parseCoinName<SupportStakeCoins>(
+        spool.marketCoinName
+      );
+      const rewardCoinName = query.utils.getSpoolRewardCoinName(
+        spool.marketCoinName
+      );
+      const marketPool = marketPools[coinName];
+      spool.coinPrice = coinPrices[coinName] || spool.coinPrice;
+      spool.marketCoinPrice =
+        (coinPrices[coinName] ?? 0) *
+          (marketPool ? marketPool.conversionRate : 0) || spool.marketCoinPrice;
+      spool.rewardCoinPrice =
+        coinPrices[rewardCoinName] || spool.rewardCoinPrice;
+      spools[spool.marketCoinName] = spool;
+    }
+
+    return spools;
+  }
+
   for (const stakeMarketCoinName of stakeMarketCoinNames) {
     const stakeCoinName =
       query.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName);
     const spool = await getSpool(
       query,
       stakeMarketCoinName,
-      marketPool[stakeCoinName]
+      indexer,
+      marketPools[stakeCoinName],
+      coinPrices
     );
 
     if (spool) {
@@ -59,22 +97,43 @@ export const getSpools = async (
  *
  * @param query - The Scallop query instance.
  * @param marketCoinName - Specific support stake market coin name.
+ * @param indexer - Whether to use indexer.
  * @param marketPool - The market pool data.
+ * @param coinPrices - The coin prices.
  * @return Spool data.
  */
 export const getSpool = async (
   query: ScallopQuery,
   marketCoinName: SupportStakeMarketCoins,
-  marketPool?: MarketPool
+  indexer: boolean = false,
+  marketPool?: MarketPool,
+  coinPrices?: CoinPrices
 ) => {
   const coinName = query.utils.parseCoinName<SupportStakeCoins>(marketCoinName);
-  marketPool = marketPool || (await query.getMarketPool(coinName));
+  marketPool = marketPool || (await query.getMarketPool(coinName, indexer));
   const spoolPkgId = query.address.get(`spool.id`);
   const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
   const rewardPoolId = query.address.get(
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool: Spool | undefined = undefined;
+
+  if (indexer) {
+    const spoolIndexer = await query.indexer.getSpool(marketCoinName);
+    const coinName =
+      query.utils.parseCoinName<SupportStakeCoins>(marketCoinName);
+    const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
+    spoolIndexer.coinPrice = coinPrices?.[coinName] || spoolIndexer.coinPrice;
+    spoolIndexer.marketCoinPrice =
+      (coinPrices?.[coinName] ?? 0) *
+        (marketPool ? marketPool.conversionRate : 0) ||
+      spoolIndexer.marketCoinPrice;
+    spoolIndexer.rewardCoinPrice =
+      coinPrices?.[rewardCoinName] || spoolIndexer.rewardCoinPrice;
+
+    return spoolIndexer;
+  }
+
   const spoolObjectResponse = await query.suiKit.client().multiGetObjects({
     ids: [poolId, rewardPoolId],
     options: {
@@ -97,10 +156,9 @@ export const getSpool = async (
     spoolObjectResponse[1].data
   ) {
     const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
-    const coinPrices = await query.utils.getCoinPrices([
-      coinName,
-      rewardCoinName,
-    ]);
+    coinPrices =
+      coinPrices ||
+      (await query.utils.getCoinPrices([coinName, rewardCoinName]));
 
     const spoolObject = spoolObjectResponse[0].data;
     const rewardPoolObject = spoolObjectResponse[1].data;