@scallop-io/sui-scallop-sdk 2.3.10 → 2.3.12

package/src/queries/portfolioQuery.ts

@@ -427,12 +427,6 @@ export const getObligationAccount = async (
       query.getBorrowIncentiveAccounts(obligation),
     ]);
 
-  console.log({
-    obligationQuery,
-    borrowIncentivePools,
-    borrowIncentiveAccounts,
-  });
-
   const collaterals: ObligationAccount['collaterals'] = {};
   const debts: ObligationAccount['debts'] = {};
   const borrowIncentives: ObligationAccount['borrowIncentives'] = {};
@@ -518,69 +512,6 @@ export const getObligationAccount = async (
     ]),
   ];
 
-  for (const assetCoinName of borrowAssetCoinNames) {
-    const debt = obligationQuery?.debts.find((debt) => {
-      const poolCoinName = query.utils.parseCoinNameFromType(debt.type.name);
-      return assetCoinName === poolCoinName;
-    });
-
-    const marketPool = market.pools[assetCoinName];
-    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
-    const coinPrice = coinPrices?.[assetCoinName] ?? 0;
-    const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
-
-    if (marketPool) {
-      const increasedRate = debt?.borrowIndex
-        ? marketPool.borrowIndex / Number(debt.borrowIndex) - 1
-        : 0;
-      const borrowedAmount = BigNumber(debt?.amount ?? 0).multipliedBy(
-        increasedRate + 1
-      );
-      const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
-
-      const requiredRepayAmount = borrowedAmount;
-      const requiredRepayCoin = requiredRepayAmount.shiftedBy(-1 * coinDecimal);
-
-      const availableRepayAmount = BigNumber(coinAmount);
-      const availableRepayCoin = availableRepayAmount.shiftedBy(
-        -1 * coinDecimal
-      );
-
-      const borrowedValue = requiredRepayCoin.multipliedBy(coinPrice);
-      const borrowedValueWithWeight = borrowedValue.multipliedBy(
-        marketPool.borrowWeight
-      );
-
-      totalBorrowedValue = totalBorrowedValue.plus(borrowedValue);
-      totalBorrowedValueWithWeight = totalBorrowedValueWithWeight.plus(
-        borrowedValueWithWeight
-      );
-
-      if (borrowedAmount.isGreaterThan(0)) {
-        totalBorrowedPools++;
-      }
-
-      debts[assetCoinName] = {
-        coinName: assetCoinName,
-        coinType: query.utils.parseCoinType(assetCoinName),
-        symbol: query.utils.parseSymbol(assetCoinName),
-        coinDecimal: coinDecimal,
-        coinPrice: coinPrice,
-        borrowedAmount: borrowedAmount.toNumber(),
-        borrowedCoin: borrowedCoin.toNumber(),
-        borrowedValue: borrowedValue.toNumber(),
-        borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
-        borrowIndex: Number(debt?.borrowIndex ?? 0),
-        requiredRepayAmount: requiredRepayAmount.toNumber(),
-        requiredRepayCoin: requiredRepayCoin.toNumber(),
-        availableBorrowAmount: 0,
-        availableBorrowCoin: 0,
-        availableRepayAmount: availableRepayAmount.toNumber(),
-        availableRepayCoin: availableRepayCoin.toNumber(),
-      };
-    }
-  }
-
   for (const [poolCoinName, borrowIncentiveAccount] of Object.entries(
     borrowIncentiveAccounts
   )) {
@@ -622,22 +553,29 @@ export const getObligationAccount = async (
 
             // for veSCA
             const weightScale = BigNumber(1_000_000_000_000);
+            const boostScale = BigNumber(poolPoint.baseWeight).dividedBy(
+              weightScale
+            );
             const boostValue = BigNumber(accountPoint.weightedAmount)
               .div(
-                BigNumber(borrowIncentiveAccount.debtAmount)
-                  .multipliedBy(poolPoint.baseWeight)
-                  .dividedBy(weightScale)
+                BigNumber(borrowIncentiveAccount.debtAmount).multipliedBy(
+                  boostScale
+                )
               )
               .isFinite()
               ? BigNumber(accountPoint.weightedAmount)
                   .div(
-                    BigNumber(borrowIncentiveAccount.debtAmount)
-                      .multipliedBy(poolPoint.baseWeight)
-                      .dividedBy(weightScale)
+                    BigNumber(borrowIncentiveAccount.debtAmount).multipliedBy(
+                      boostScale
+                    )
                   )
                   .toNumber()
               : 1;
 
+            const rewardApr = isFinite(poolPoint.rewardApr)
+              ? poolPoint.rewardApr
+              : 0;
+
             if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
               rewards.push({
                 coinName: poolPoint.coinName,
@@ -648,6 +586,9 @@ export const getObligationAccount = async (
                 weightedBorrowAmount: accountBorrowedAmount.toNumber(),
                 availableClaimAmount: availableClaimAmount.toNumber(),
                 availableClaimCoin: availableClaimCoin.toNumber(),
+                baseRewardApr: rewardApr,
+                boostedRewardApr: rewardApr * boostValue,
+                maxBoost: 1 / boostScale.toNumber(),
                 boostValue,
               });
             }
@@ -680,6 +621,72 @@ export const getObligationAccount = async (
     }
   }
 
+  for (const assetCoinName of borrowAssetCoinNames) {
+    const debt = obligationQuery?.debts.find((debt) => {
+      const poolCoinName = query.utils.parseCoinNameFromType(debt.type.name);
+      return assetCoinName === poolCoinName;
+    });
+
+    const marketPool = market.pools[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
+    const coinPrice = coinPrices?.[assetCoinName] ?? 0;
+    const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
+
+    if (marketPool) {
+      const increasedRate = debt?.borrowIndex
+        ? marketPool.borrowIndex / Number(debt.borrowIndex) - 1
+        : 0;
+      const borrowedAmount = BigNumber(debt?.amount ?? 0).multipliedBy(
+        increasedRate + 1
+      );
+      const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
+
+      const requiredRepayAmount = borrowedAmount;
+      const requiredRepayCoin = requiredRepayAmount.shiftedBy(-1 * coinDecimal);
+
+      const availableRepayAmount = BigNumber(coinAmount);
+      const availableRepayCoin = availableRepayAmount.shiftedBy(
+        -1 * coinDecimal
+      );
+
+      const borrowedValue = requiredRepayCoin.multipliedBy(coinPrice);
+      const borrowedValueWithWeight = borrowedValue.multipliedBy(
+        marketPool.borrowWeight
+      );
+
+      totalBorrowedValue = totalBorrowedValue.plus(borrowedValue);
+      totalBorrowedValueWithWeight = totalBorrowedValueWithWeight.plus(
+        borrowedValueWithWeight
+      );
+
+      if (borrowedAmount.isGreaterThan(0)) {
+        totalBorrowedPools++;
+      }
+
+      debts[assetCoinName] = {
+        coinName: assetCoinName,
+        coinType: query.utils.parseCoinType(assetCoinName),
+        symbol: query.utils.parseSymbol(assetCoinName),
+        coinDecimal: coinDecimal,
+        coinPrice: coinPrice,
+        borrowedAmount: borrowedAmount.toNumber(),
+        borrowedCoin: borrowedCoin.toNumber(),
+        borrowedValue: borrowedValue.toNumber(),
+        borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
+        borrowIndex: Number(debt?.borrowIndex ?? 0),
+        requiredRepayAmount: requiredRepayAmount.toNumber(),
+        requiredRepayCoin: requiredRepayCoin.toNumber(),
+        availableBorrowAmount: 0,
+        availableBorrowCoin: 0,
+        availableRepayAmount: availableRepayAmount.toNumber(),
+        availableRepayCoin: availableRepayCoin.toNumber(),
+        rewards: (borrowIncentives[assetCoinName]?.rewards ?? []).filter(
+          ({ weightedBorrowAmount }) => weightedBorrowAmount > 0
+        ),
+      };
+    }
+  }
+
   let riskLevel = totalRequiredCollateralValue.isZero()
     ? // Note: when there is no collateral and debt is not zero, then it's a bad-debt situation.
       totalBorrowedValueWithWeight.isGreaterThan(0)
@@ -911,24 +918,19 @@ export const getUserPortfolio = async (
   const coinPrices = await query.getAllCoinPrices({ indexer });
   const market = await query.getMarketPools(undefined, { indexer, coinPrices });
 
-  const [lendings, obligationAccounts, borrowIncentivePools, veScas] =
-    await Promise.all([
-      query.getLendings(undefined, walletAddress, {
-        indexer,
-        marketPools: market.pools,
-        coinPrices,
-      }),
-      query.getObligationAccounts(walletAddress, {
-        indexer,
-        market: market,
-        coinPrices,
-      }),
-      query.getBorrowIncentivePools(undefined, {
-        marketPools: market.pools,
-        coinPrices,
-      }),
-      query.getVeScas({ walletAddress, excludeEmpty: true }),
-    ]);
+  const [lendings, obligationAccounts, veScas] = await Promise.all([
+    query.getLendings(undefined, walletAddress, {
+      indexer,
+      marketPools: market.pools,
+      coinPrices,
+    }),
+    query.getObligationAccounts(walletAddress, {
+      indexer,
+      market: market,
+      coinPrices,
+    }),
+    query.getVeScas({ walletAddress, excludeEmpty: true }),
+  ]);
 
   // get pending rewards (spool and borrow incentive)
   const parsedLendings = Object.values(lendings)
@@ -983,29 +985,35 @@ export const getUserPortfolio = async (
             (debt): debt is NonNullable<typeof debt> =>
               !!debt && debt.borrowedCoin > 0
           )
-          .map((debt) => ({
-            coinName: debt.coinName,
-            symbol: debt.symbol,
-            coinDecimals: debt.coinDecimal,
-            coinType: debt.coinType,
-            coinPrice: debt.coinPrice,
-            borrowedCoin: debt.borrowedCoin,
-            borrowedValueInUsd: debt.borrowedValueWithWeight,
-            borrowApr: market.pools[debt.coinName]?.borrowApr,
-            borrowApy: market.pools[debt.coinName]?.borrowApy,
-            incentiveInfos: Object.values(
-              borrowIncentivePools[debt.coinName]?.points ?? {}
-            )
-              .filter(
-                (t): t is NonNullable<typeof t> => !!t && isFinite(t.rewardApr)
+          .map((debt) => {
+            return {
+              coinName: debt.coinName,
+              symbol: debt.symbol,
+              coinDecimals: debt.coinDecimal,
+              coinType: debt.coinType,
+              coinPrice: debt.coinPrice,
+              borrowedCoin: debt.borrowedCoin,
+              borrowedValueInUsd: debt.borrowedValueWithWeight,
+              borrowApr: market.pools[debt.coinName]?.borrowApr,
+              borrowApy: market.pools[debt.coinName]?.borrowApy,
+              incentiveInfos: (
+                obligationAccount.borrowIncentives[debt.coinName]?.rewards ?? []
               )
-              .map((t) => ({
-                coinName: t.coinName,
-                symbol: t.symbol,
-                coinType: t.coinType,
-                incentiveApr: t.rewardApr,
-              })),
-          })),
+                .filter(
+                  (t): t is NonNullable<typeof t> =>
+                    !!t && isFinite(t.baseRewardApr)
+                )
+                .map((t) => ({
+                  coinName: t.coinName,
+                  symbol: t.symbol,
+                  coinType: t.coinType,
+                  boostValue: t.boostValue,
+                  maxBoost: t.maxBoost,
+                  incentiveApr: t.baseRewardApr,
+                  boostedIncentiveApr: t.boostedRewardApr,
+                })),
+            };
+          }),
       };
     });
 

package/src/queries/priceQuery.ts

@@ -1,134 +1,6 @@
-import { SuiObjectData } from '@mysten/sui/client';
-import type { ScallopAddress, ScallopQuery, ScallopSuiKit } from 'src/models';
-import type { CoinPrices, MarketPools, OptionalKeys } from '../types';
 import BigNumber from 'bignumber.js';
-
-/**
- * Get price from pyth fee object.
- *
- * @param query - The Scallop query instance.
- * @param assetCoinName - Specific support asset coin name.
- * @return Asset coin price.
- */
-export const getPythPrice = async (
-  {
-    address,
-    scallopSuiKit,
-  }: {
-    address: ScallopAddress;
-    scallopSuiKit: ScallopSuiKit;
-  },
-  assetCoinName: string,
-  priceFeedObject?: SuiObjectData | null
-) => {
-  const pythFeedObjectId = address.get(
-    `core.coins.${assetCoinName}.oracle.pyth.feedObject`
-  );
-  priceFeedObject =
-    priceFeedObject ||
-    (await scallopSuiKit.queryGetObject(pythFeedObjectId))?.data;
-
-  if (priceFeedObject) {
-    const priceFeedPoolObject = priceFeedObject;
-    if (
-      priceFeedPoolObject.content &&
-      'fields' in priceFeedPoolObject.content
-    ) {
-      const fields = priceFeedPoolObject.content.fields as any;
-      const expoMagnitude = Number(
-        fields.price_info.fields.price_feed.fields.price.fields.expo.fields
-          .magnitude
-      );
-      const expoNegative = Number(
-        fields.price_info.fields.price_feed.fields.price.fields.expo.fields
-          .negative
-      );
-      const priceMagnitude = Number(
-        fields.price_info.fields.price_feed.fields.price.fields.price.fields
-          .magnitude
-      );
-      const priceNegative = Number(
-        fields.price_info.fields.price_feed.fields.price.fields.price.fields
-          .negative
-      );
-
-      return (
-        priceMagnitude *
-        10 ** ((expoNegative ? -1 : 1) * expoMagnitude) *
-        (priceNegative ? -1 : 1)
-      );
-    }
-  }
-
-  return 0;
-};
-
-export const getPythPrices = async (
-  {
-    address,
-    scallopSuiKit,
-  }: {
-    address: ScallopAddress;
-    scallopSuiKit: ScallopSuiKit;
-  },
-  assetCoinNames: string[]
-) => {
-  const pythPriceFeedIds = assetCoinNames.reduce(
-    (prev, assetCoinName) => {
-      const pythPriceFeed = address.get(
-        `core.coins.${assetCoinName}.oracle.pyth.feedObject`
-      );
-      if (pythPriceFeed) {
-        if (!prev[pythPriceFeed]) {
-          prev[pythPriceFeed] = [assetCoinName];
-        } else {
-          prev[pythPriceFeed].push(assetCoinName);
-        }
-      }
-      return prev;
-    },
-    {} as Record<string, string[]>
-  );
-
-  // Fetch multiple objects at once to save rpc calls
-  const priceFeedObjects = await scallopSuiKit.queryGetObjects(
-    Object.keys(pythPriceFeedIds)
-  );
-
-  const assetToPriceFeedMapping = priceFeedObjects.reduce(
-    (prev, priceFeedObject) => {
-      pythPriceFeedIds[priceFeedObject.objectId].forEach((assetCoinName) => {
-        prev[assetCoinName] = priceFeedObject;
-      });
-      return prev;
-    },
-    {} as Record<string, SuiObjectData>
-  );
-
-  return (
-    await Promise.all(
-      Object.entries(assetToPriceFeedMapping).map(
-        async ([assetCoinName, priceFeedObject]) => ({
-          coinName: assetCoinName,
-          price: await getPythPrice(
-            {
-              address,
-              scallopSuiKit,
-            },
-            assetCoinName as string,
-            priceFeedObject
-          ),
-        })
-      )
-    )
-  ).reduce(
-    (prev, curr) => {
-      prev[curr.coinName as string] = curr.price;
-      return prev;
-    },
-    {} as Record<string, number>
-  );
-};
+import type { ScallopQuery } from 'src/models';
+import type { CoinPrices, MarketPools, OptionalKeys } from '../types';
 
 export const getAllCoinPrices = async (
   query: ScallopQuery,

package/src/queries/vescaQuery.ts

@@ -192,13 +192,18 @@ const getTotalVeScaTreasuryAmount = async (
     initialSharedVersion: '1',
   });
 
-  const treasuryRef = txb.sharedObjectRef({
-    ...(await getSharedObjectData(
+  const [treasuryVersion, veScaConfigVersion] = await Promise.all([
+    getSharedObjectData(
       typeof veScaTreasury === 'string'
         ? veScaTreasury
         : veScaTreasury.objectId,
       utils.scallopSuiKit
-    )),
+    ),
+    getSharedObjectData(veScaConfig, utils.scallopSuiKit),
+  ]);
+
+  const treasuryRef = txb.sharedObjectRef({
+    ...treasuryVersion,
     mutable: true,
   });
 
@@ -206,7 +211,7 @@ const getTotalVeScaTreasuryAmount = async (
   const refreshQueryTarget = `${veScaPkgId}::treasury::refresh`;
   const refreshArgs = [
     txb.sharedObjectRef({
-      ...(await getSharedObjectData(veScaConfig, utils.scallopSuiKit)),
+      ...veScaConfigVersion,
       mutable: false,
     }),
     treasuryRef,

package/src/types/query/portfolio.ts

@@ -69,6 +69,7 @@ export type ObligationAccount = {
   totalRewardedPools: number;
   collaterals: OptionalKeys<Record<string, ObligationCollateral>>;
   debts: OptionalKeys<Record<string, ObligationDebt>>;
+  // @deprecated: incentive info moved to 'debts' field
   borrowIncentives: OptionalKeys<Record<string, ObligationBorrowIncentive>>;
 };
 
@@ -106,6 +107,12 @@ export type ObligationDebt = {
   availableBorrowCoin: number;
   availableRepayAmount: number;
   availableRepayCoin: number;
+  rewards: {
+    boostValue: number;
+    maxBoost: number;
+    baseRewardApr: number;
+    boostedRewardApr: number;
+  }[];
 };
 
 export type ObligationBorrowIncentiveReward = {
@@ -117,7 +124,10 @@ export type ObligationBorrowIncentiveReward = {
   weightedBorrowAmount: number;
   availableClaimCoin: number;
   availableClaimAmount: number;
+  baseRewardApr: number;
   boostValue: number;
+  boostedRewardApr: number;
+  maxBoost: number;
 };
 
 export type ObligationBorrowIncentive = {

package/src/utils/query.ts

@@ -524,22 +524,17 @@ export const calculateBorrowIncentivePoolPointData = (
     .multipliedBy(rewardCoinPrice);
 
   const weightScale = BigNumber(1_000_000_000_000);
+  const rewardScale = BigNumber(
+    parsedBorrowIncentivePoolPointData.baseWeight
+  ).dividedBy(weightScale);
 
   const rewardRate =
     rewardValueForYear
-      .multipliedBy(
-        BigNumber(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
-          weightScale
-        )
-      )
+      .multipliedBy(rewardScale)
       .dividedBy(weightedStakedValue)
       .isFinite() && parsedBorrowIncentivePoolPointData.points > 0
       ? rewardValueForYear
-          .multipliedBy(
-            BigNumber(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
-              weightScale
-            )
-          )
+          .multipliedBy(rewardScale)
           .dividedBy(weightedStakedValue)
           .toNumber()
       : Infinity;