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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "2.3.11",
+  "version": "2.3.12",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",

package/src/models/scallopAddress.ts

@@ -442,7 +442,7 @@ class ScallopAddress {
   public readonly scallopAxios: ScallopAxios;
   private readonly addressMap = new Map<NetworkType, AddressesInterface>();
   private readonly defaultParamValues = {
-    addressId: '67c44a103fe1b8c454eb9699',
+    addressId: '695fcdc084f790c04eb068dc',
     network: 'mainnet' as NetworkType,
   } as const;
 

package/src/models/scallopQuery.ts

@@ -37,8 +37,6 @@ import {
   getOnDemandAggObjectIds,
   getPoolAddresses,
   getPriceUpdatePolicies,
-  getPythPrice,
-  getPythPrices,
   getSCoinAmount,
   getSCoinAmounts,
   getSCoinSwapRate,
@@ -321,7 +319,7 @@ class ScallopQuery implements ScallopQueryInterface {
    * @return Asset coin price.
    */
   async getPriceFromPyth(assetCoinName: string) {
-    return await getPythPrice(this, assetCoinName);
+    return await this.utils.getPythPrice(assetCoinName);
   }
 
   /**
@@ -331,7 +329,7 @@ class ScallopQuery implements ScallopQueryInterface {
    * @return Array of asset coin prices.
    */
   async getPricesFromPyth(assetCoinNames: string[]) {
-    return await getPythPrices(this, assetCoinNames);
+    return await this.utils.getPythPrices(assetCoinNames);
   }
 
   /* ==================== Spool Query Methods ==================== */
@@ -855,8 +853,11 @@ class ScallopQuery implements ScallopQueryInterface {
   /**
    * Check if asset is an isolated asset
    */
-  async isIsolatedAsset(assetCoinName: string) {
-    return isIsolatedAsset(this.utils, assetCoinName);
+  async isIsolatedAsset(
+    assetCoinName: string,
+    useOnChainQuery: boolean = false
+  ) {
+    return isIsolatedAsset(this.utils, assetCoinName, useOnChainQuery);
   }
 
   /**

package/src/models/scallopUtils.ts

@@ -483,13 +483,15 @@ class ScallopUtils implements ScallopUtilsInterface {
     return (
       await Promise.all(
         Object.entries(assetToPriceFeedMapping).map(
-          async ([assetCoinName, priceFeedObject]) => ({
-            coinName: assetCoinName,
-            price: await this.getPythPrice(
-              assetCoinName as string,
-              priceFeedObject
-            ),
-          })
+          async ([coinName, feed]) => {
+            try {
+              const price = await this.getPythPrice(coinName, feed);
+              return { coinName, price };
+            } catch (e) {
+              console.error(e);
+              return { coinName, price: 0 };
+            }
+          }
         )
       )
     ).reduce(

package/src/queries/borrowIncentiveQuery.ts

@@ -31,7 +31,7 @@ import { queryKeys } from 'src/constants';
  * @param address
  * @returns
  */
-export const queryBorrowIncentivePools = async ({
+const queryBorrowIncentivePools = async ({
   address,
   scallopSuiKit,
 }: {
@@ -135,17 +135,19 @@ export const getBorrowIncentivePools = async (
         poolCoinDecimal
       );
 
-      borrowIncentivePoolPoints[coinName as string] = {
-        symbol,
-        coinName: rewardCoinName,
-        coinType: rewardCoinType,
-        coinDecimal,
-        coinPrice: rewardCoinPrice,
-        points: poolPoint.points,
-        distributedPoint: poolPoint.distributedPoint,
-        weightedAmount: poolPoint.weightedAmount,
-        ...calculatedPoolPoint,
-      };
+      if (poolPoint.points > calculatedPoolPoint.accumulatedPoints) {
+        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);
@@ -186,13 +188,18 @@ export const queryBorrowIncentiveAccounts = async (
     'borrowIncentive.incentiveAccounts'
   );
   const queryTarget = `${queryPkgId}::incentive_account_query::incentive_account_data`;
+  const [incentiveAccountVersion, obligationDataVersion] = await Promise.all([
+    getSharedObjectData(incentiveAccountsId, utils.scallopSuiKit),
+    getSharedObjectData(obligationId, utils.scallopSuiKit),
+  ]);
+
   const args = [
     txBlock.sharedObjectRef({
-      ...(await getSharedObjectData(incentiveAccountsId, utils.scallopSuiKit)),
+      ...incentiveAccountVersion,
       mutable: true,
     }),
     txBlock.sharedObjectRef({
-      ...(await getSharedObjectData(obligationId, utils.scallopSuiKit)),
+      ...obligationDataVersion,
       mutable: true,
     }),
   ];

package/src/queries/coreQuery.ts

@@ -956,17 +956,23 @@ export const queryObligation = async (
   const market = address.get('core.market');
   const queryTarget = `${packageId}::obligation_query::obligation_data`;
 
+  const [versionData, marketData, obligationData] = await Promise.all([
+    getSharedObjectData(version, scallopSuiKit),
+    getSharedObjectData(market, scallopSuiKit),
+    getSharedObjectData(obligationId, scallopSuiKit),
+  ]);
+
   const args = [
     txBlock.sharedObjectRef({
-      ...(await getSharedObjectData(version, scallopSuiKit)),
+      ...versionData,
       mutable: false,
     }),
     txBlock.sharedObjectRef({
-      ...(await getSharedObjectData(market, scallopSuiKit)),
+      ...marketData,
       mutable: true,
     }),
     txBlock.sharedObjectRef({
-      ...(await getSharedObjectData(obligationId, scallopSuiKit)),
+      ...obligationData,
       mutable: true,
     }),
     {

package/src/queries/isolatedAssetQuery.ts

@@ -81,15 +81,18 @@ export const getIsolatedAssets = async (
 
 /**
  * Check if the coin type is an isolated asset
+ * @param utils ScallopUtils
  * @param coinName coin name
+ * @param useOnChainQuery whether to use on-chain query
  * @returns true if the coin type is an isolated asset
  */
 export const isIsolatedAsset = async (
   utils: ScallopUtils,
-  coinName: string
+  coinName: string,
+  useOnChainQuery?: boolean
 ): Promise<boolean> => {
   const assetInPoolAddresses = utils.constants.poolAddresses[coinName];
-  if (assetInPoolAddresses) {
+  if (assetInPoolAddresses && !useOnChainQuery) {
     return assetInPoolAddresses.isIsolated;
   }
 

package/src/queries/portfolioQuery.ts

@@ -512,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
   )) {
@@ -616,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,
@@ -642,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,
               });
             }
@@ -674,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)
@@ -905,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)
@@ -977,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 = {