@scallop-io/sui-scallop-sdk 0.44.2 → 0.44.4

package/src/models/scallopQuery.ts

@@ -6,7 +6,7 @@ import {
   queryObligation,
   getStakeAccounts,
   getStakePool,
-  getRewardPool,
+  getStakeRewardPool,
   getPythPrice,
   getMarketPools,
   getMarketPool,
@@ -14,6 +14,8 @@ import {
   getMarketCollateral,
   getSpools,
   getSpool,
+  queryBorrowIncentivePools,
+  queryBorrowIncentiveAccounts,
   getCoinAmounts,
   getCoinAmount,
   getMarketCoinAmounts,
@@ -33,7 +35,8 @@ import {
   SupportCollateralCoins,
   SupportMarketCoins,
   StakePools,
-  RewardPools,
+  StakeRewardPools,
+  SupportBorrowIncentiveCoins,
 } from '../types';
 import { ScallopAddress } from './scallopAddress';
 import { ScallopUtils } from './scallopUtils';
@@ -323,43 +326,74 @@ export class ScallopQuery {
   }
 
   /**
-   * Get reward pools data.
+   * Get stake reward pools data.
    *
    * @description
    * For backward compatible, it is recommended to use `getSpools` method
    * to get all spools data.
    *
    * @param stakeMarketCoinNames - Specific an array of stake market coin name.
-   * @return Reward pools data.
+   * @return Stake reward pools data.
    */
-  public async getRewardPools(
+  public async getStakeRewardPools(
     stakeMarketCoinNames?: SupportStakeMarketCoins[]
   ) {
     stakeMarketCoinNames = stakeMarketCoinNames ?? [...SUPPORT_SPOOLS];
-    const rewardPools: RewardPools = {};
+    const stakeRewardPools: StakeRewardPools = {};
     for (const stakeMarketCoinName of stakeMarketCoinNames) {
-      const rewardPool = await getRewardPool(this, stakeMarketCoinName);
+      const stakeRewardPool = await getStakeRewardPool(
+        this,
+        stakeMarketCoinName
+      );
 
-      if (rewardPool) {
-        rewardPools[stakeMarketCoinName] = rewardPool;
+      if (stakeRewardPool) {
+        stakeRewardPools[stakeMarketCoinName] = stakeRewardPool;
       }
     }
 
-    return rewardPools;
+    return stakeRewardPools;
   }
 
   /**
-   * Get reward pool data.
+   * Get stake reward pool data.
    *
    * @description
    * For backward compatible, it is recommended to use `getSpool` method
    * to get spool data.
    *
    * @param marketCoinName - Specific support stake market coin name.
-   * @return Reward pool data.
+   * @return Stake reward pool data.
    */
-  public async getRewardPool(stakeMarketCoinName: SupportStakeMarketCoins) {
-    return await getRewardPool(this, stakeMarketCoinName);
+  public async getStakeRewardPool(
+    stakeMarketCoinName: SupportStakeMarketCoins
+  ) {
+    return await getStakeRewardPool(this, stakeMarketCoinName);
+  }
+
+  /**
+   * Get borrow incentive pools data.
+   *
+   * @param coinNames - Specific an array of support borrow incentive coin name.
+   * @return Borrow incentive pools data.
+   */
+  public async getBorrowIncentivePools(
+    coinNames?: SupportBorrowIncentiveCoins[]
+  ) {
+    return await queryBorrowIncentivePools(this, coinNames);
+  }
+
+  /**
+   * Get borrow incentive accounts data.
+   *
+   * @param coinNames - Specific support borrow incentive coin name.
+   * @param ownerAddress - The owner address.
+   * @return Borrow incentive accounts data.
+   */
+  public async getBorrowIncentiveAccounts(
+    obligationId: string,
+    coinNames?: SupportBorrowIncentiveCoins[]
+  ) {
+    return await queryBorrowIncentiveAccounts(this, obligationId, coinNames);
   }
 
   /**

package/src/models/scallopUtils.ts

@@ -8,7 +8,8 @@ import {
   PROTOCOL_OBJECT_ID,
   SUPPORT_POOLS,
   SUPPORT_COLLATERALS,
-  rewardCoins,
+  spoolRewardCoins,
+  borrowIncentiveRewardCoins,
   coinDecimals,
   wormholeCoinIds,
   voloCoinIds,
@@ -27,6 +28,7 @@ import type {
   SupportAssetCoins,
   SupportMarketCoins,
   SupportStakeMarketCoins,
+  SupportBorrowIncentiveCoins,
   CoinPrices,
   PriceMap,
   CoinWrappedType,
@@ -246,13 +248,27 @@ export class ScallopUtils {
   }
 
   /**
-   * Get reward type of stake pool.
+   * Get reward type of spool.
    *
    * @param stakeMarketCoinName - Support stake market coin.
-   * @return Reward coin name.
+   * @return Spool reward coin name.
    */
-  public getRewardCoinName = (stakeMarketCoinName: SupportStakeMarketCoins) => {
-    return rewardCoins[stakeMarketCoinName];
+  public getSpoolRewardCoinName = (
+    stakeMarketCoinName: SupportStakeMarketCoins
+  ) => {
+    return spoolRewardCoins[stakeMarketCoinName];
+  };
+
+  /**
+   * Get reward type of borrow incentive pool.
+   *
+   * @param borrowIncentiveCoinName - Support borrow incentive coin.
+   * @return Borrow incentive reward coin name.
+   */
+  public getBorrowIncentiveRewardCoinName = (
+    borrowIncentiveCoinName: SupportBorrowIncentiveCoins
+  ) => {
+    return borrowIncentiveRewardCoins[borrowIncentiveCoinName];
   };
 
   /**

package/src/queries/borrowIncentiveQuery.ts

@@ -0,0 +1,167 @@
+import { normalizeStructTag } from '@mysten/sui.js/utils';
+import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
+import { SUPPORT_BORROW_INCENTIVE_POOLS } from '../constants';
+import {
+  parseOriginBorrowIncentivePoolData,
+  calculateBorrowIncentivePoolData,
+  parseOriginBorrowIncentiveRewardPoolData,
+  calculateBorrowIncentiveRewardPoolData,
+  parseOriginBorrowIncentiveAccountData,
+} from '../utils';
+import type { ScallopQuery } from '../models';
+import type {
+  BorrowIncentivePoolsQueryInterface,
+  BorrowIncentivePools,
+  BorrowIncentiveAccountsQueryInterface,
+  BorrowIncentiveAccounts,
+  SupportBorrowIncentiveCoins,
+  SupportAssetCoins,
+} from '../types';
+
+/**
+ * Query borrow incentive pools data.
+ *
+ * @param query - The Scallop query instance.
+ * @param borrowIncentiveCoinNames - Specific an array of support borrow incentive coin name.
+ * @return Borrow incentive pools data.
+ */
+export const queryBorrowIncentivePools = async (
+  query: ScallopQuery,
+  borrowIncentiveCoinNames?: SupportBorrowIncentiveCoins[]
+) => {
+  borrowIncentiveCoinNames = borrowIncentiveCoinNames || [
+    ...SUPPORT_BORROW_INCENTIVE_POOLS,
+  ];
+  const queryPkgId = query.address.get('borrowIncentive.query');
+  const incentivePoolsId = query.address.get('borrowIncentive.incentivePools');
+  const txBlock = new SuiKitTxBlock();
+  const queryTarget = `${queryPkgId}::incentive_pools_query::incentive_pools_data`;
+  // The reward coin type currently only support sui, so bring it in directly here.
+  txBlock.moveCall(queryTarget, [incentivePoolsId], ['0x2::sui::SUI']);
+  const queryResult = await query.suiKit.inspectTxn(txBlock);
+  const borrowIncentivePoolsQueryData = queryResult.events[0]
+    .parsedJson as BorrowIncentivePoolsQueryInterface;
+
+  const parsedBorrowIncentiveRewardPoolData =
+    parseOriginBorrowIncentiveRewardPoolData(
+      borrowIncentivePoolsQueryData.reward_pool
+    );
+  const rewardCoinType = parsedBorrowIncentiveRewardPoolData.rewardType;
+
+  const borrowIncentivePools: BorrowIncentivePools = {};
+  for (const pool of borrowIncentivePoolsQueryData.incentive_pools) {
+    const coinType = normalizeStructTag(pool.pool_type.name);
+    const coinName =
+      query.utils.parseCoinNameFromType<SupportBorrowIncentiveCoins>(coinType);
+    const rewardCoinName =
+      query.utils.parseCoinNameFromType<SupportAssetCoins>(rewardCoinType);
+
+    // Filter pools not yet supported by the SDK.
+    if (!borrowIncentiveCoinNames.includes(coinName)) {
+      continue;
+    }
+
+    const coinPrices = await query.utils.getCoinPrices([
+      coinName,
+      rewardCoinName,
+    ]);
+
+    const parsedBorrowIncentivePoolData =
+      parseOriginBorrowIncentivePoolData(pool);
+
+    const coinPrice = coinPrices?.[coinName] ?? 0;
+    const coinDecimal = query.utils.getCoinDecimal(coinName);
+    const calculatedBorrowIncentivePoolData = calculateBorrowIncentivePoolData(
+      parsedBorrowIncentivePoolData,
+      coinPrice,
+      coinDecimal
+    );
+
+    const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+    const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+    const calculatedBorrowIncentiveRewardPoolData =
+      calculateBorrowIncentiveRewardPoolData(
+        parsedBorrowIncentivePoolData,
+        parsedBorrowIncentiveRewardPoolData,
+        calculatedBorrowIncentivePoolData,
+        rewardCoinPrice,
+        rewardCoinDecimal
+      );
+
+    borrowIncentivePools[coinName] = {
+      coinName: coinName,
+      symbol: query.utils.parseSymbol(coinName),
+      coinType: coinType,
+      rewardCoinType: rewardCoinType,
+      coinDecimal: coinDecimal,
+      rewardCoinDecimal: rewardCoinDecimal,
+      coinPrice: coinPrice,
+      rewardCoinPrice: rewardCoinPrice,
+      maxPoint: parsedBorrowIncentivePoolData.maxPoint,
+      distributedPoint: parsedBorrowIncentivePoolData.distributedPoint,
+      maxStake: parsedBorrowIncentivePoolData.maxStake,
+      ...calculatedBorrowIncentivePoolData,
+      exchangeRateNumerator:
+        parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator,
+      exchangeRateDenominator:
+        parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator,
+      ...calculatedBorrowIncentiveRewardPoolData,
+    };
+  }
+
+  return borrowIncentivePools;
+};
+
+/**
+ * Query borrow incentive accounts data.
+ *
+ * @param query - The Scallop query instance.
+ * @param borrowIncentiveCoinNames - Specific an array of support borrow incentive coin name.
+ * @return Borrow incentive accounts data.
+ */
+export const queryBorrowIncentiveAccounts = async (
+  query: ScallopQuery,
+  obligationId: string,
+  borrowIncentiveCoinNames?: SupportBorrowIncentiveCoins[]
+) => {
+  borrowIncentiveCoinNames = borrowIncentiveCoinNames || [
+    ...SUPPORT_BORROW_INCENTIVE_POOLS,
+  ];
+  const queryPkgId = query.address.get('borrowIncentive.query');
+  const incentiveAccountsId = query.address.get(
+    'borrowIncentive.incentiveAccounts'
+  );
+  const queryTarget = `${queryPkgId}::incentive_account_query::incentive_account_data`;
+  const txBlock = new SuiKitTxBlock();
+  txBlock.moveCall(queryTarget, [incentiveAccountsId, obligationId]);
+  const queryResult = await query.suiKit.inspectTxn(txBlock);
+  const borrowIncentiveAccountsQueryData = queryResult.events[0]
+    .parsedJson as BorrowIncentiveAccountsQueryInterface;
+
+  const borrowIncentiveAccounts: BorrowIncentiveAccounts = Object.values(
+    borrowIncentiveAccountsQueryData.incentive_states
+  ).reduce((accounts, accountData) => {
+    const parsedBorrowIncentiveAccount =
+      parseOriginBorrowIncentiveAccountData(accountData);
+    const poolType = parsedBorrowIncentiveAccount.poolType;
+    const coinName =
+      query.utils.parseCoinNameFromType<SupportBorrowIncentiveCoins>(poolType);
+
+    if (
+      borrowIncentiveCoinNames &&
+      borrowIncentiveCoinNames.includes(coinName)
+    ) {
+      accounts[coinName] = {
+        poolType: poolType,
+        amount: parsedBorrowIncentiveAccount.amount,
+        points: parsedBorrowIncentiveAccount.points,
+        totalPoints: parsedBorrowIncentiveAccount.totalPoints,
+        index: parsedBorrowIncentiveAccount.index,
+      };
+    }
+
+    return accounts;
+  }, {} as BorrowIncentiveAccounts);
+
+  return borrowIncentiveAccounts;
+};

package/src/queries/coreQuery.ts

@@ -1,3 +1,4 @@
+import { normalizeStructTag } from '@mysten/sui.js/utils';
 import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
 import BigNumber from 'bignumber.js';
 import {
@@ -59,6 +60,17 @@ export const queryMarket = async (query: ScallopQuery) => {
   const collaterals: MarketCollaterals = {};
 
   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;
+
+    // Filter pools not yet supported by the SDK.
+    if (!SUPPORT_POOLS.includes(poolCoinName)) {
+      continue;
+    }
+
     const parsedMarketPoolData = parseOriginMarketPoolData({
       type: pool.type,
       maxBorrowRate: pool.maxBorrowRate,
@@ -85,12 +97,6 @@ export const queryMarket = async (query: ScallopQuery) => {
       parsedMarketPoolData
     );
 
-    const coinType = '0x' + pool.type.name;
-    const poolCoinName =
-      query.utils.parseCoinNameFromType<SupportPoolCoins>(coinType);
-    const coinPrice =
-      (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
-
     pools[poolCoinName] = {
       coinName: poolCoinName,
       symbol: query.utils.parseSymbol(poolCoinName),
@@ -110,6 +116,19 @@ export const queryMarket = async (query: ScallopQuery) => {
   }
 
   for (const collateral of marketData.collaterals) {
+    const coinType = normalizeStructTag(collateral.type.name);
+    const collateralCoinName =
+      query.utils.parseCoinNameFromType<SupportCollateralCoins>(coinType);
+    const coinPrice =
+      (await query.utils.getCoinPrices([collateralCoinName]))?.[
+        collateralCoinName
+      ] ?? 0;
+
+    // Filter collaterals not yet supported by the SDK.
+    if (!SUPPORT_COLLATERALS.includes(collateralCoinName)) {
+      continue;
+    }
+
     const parsedMarketCollateralData = parseOriginMarketCollateralData({
       type: collateral.type,
       collateralFactor: collateral.collateralFactor,
@@ -126,14 +145,6 @@ export const queryMarket = async (query: ScallopQuery) => {
       parsedMarketCollateralData
     );
 
-    const coinType = '0x' + collateral.type.name;
-    const collateralCoinName =
-      query.utils.parseCoinNameFromType<SupportCollateralCoins>(coinType);
-    const coinPrice =
-      (await query.utils.getCoinPrices([collateralCoinName]))?.[
-        collateralCoinName
-      ] ?? 0;
-
     collaterals[collateralCoinName] = {
       coinName: collateralCoinName,
       symbol: query.utils.parseSymbol(collateralCoinName),
@@ -586,12 +597,44 @@ export const getObligations = async (
     if (keyObject.content && 'fields' in keyObject.content) {
       const fields = keyObject.content.fields as any;
       const obligationId = String(fields.ownership.fields.of);
-      obligations.push({ id: obligationId, keyId });
+      const locked = await getObligationLocked(query, obligationId);
+      obligations.push({ id: obligationId, keyId, locked });
     }
   }
   return obligations;
 };
 
+/**
+ * Query obligation locked status.
+ *
+ * @param query - The Scallop query instance.
+ * @param obligationId - The obligation id.
+ * @return Obligation locked status.
+ */
+export const getObligationLocked = async (
+  query: ScallopQuery,
+  obligationId: string
+) => {
+  const obligationObjectResponse = await query.suiKit.client().getObject({
+    id: obligationId,
+    options: {
+      showContent: true,
+    },
+  });
+  let obligationLocked = false;
+  if (
+    obligationObjectResponse.data &&
+    obligationObjectResponse?.data?.content?.dataType === 'moveObject' &&
+    'lock_key' in obligationObjectResponse.data.content.fields
+  ) {
+    obligationLocked = Boolean(
+      obligationObjectResponse.data.content.fields.lock_key
+    );
+  }
+
+  return obligationLocked;
+};
+
 /**
  * Query obligation data.
  *

package/src/queries/index.ts

@@ -1,4 +1,5 @@
 export * from './coreQuery';
 export * from './spoolQuery';
+export * from './borrowIncentiveQuery';
 export * from './priceQuery';
 export * from './portfolioQuery';

package/src/queries/portfolioQuery.ts

@@ -19,6 +19,7 @@ import type {
   CoinPrices,
   SupportMarketCoins,
   TotalValueLocked,
+  SupportBorrowIncentiveCoins,
 } from '../types';
 
 /**
@@ -164,7 +165,9 @@ export const getLending = async (
       availableUnstakeAmount = availableUnstakeAmount.plus(
         accountStakedMarketCoinAmount
       );
-      availableUnstakeCoin = availableUnstakeAmount.shiftedBy(-1 * coinDecimal);
+      availableUnstakeCoin = availableUnstakeAmount.shiftedBy(
+        -1 * spool.coinDecimal
+      );
 
       const baseIndexRate = 1_000_000_000;
       const increasedPointRate = spool?.currentPointIndex
@@ -173,13 +176,15 @@ export const getLending = async (
           )
         : 1;
       availableClaimAmount = availableClaimAmount.plus(
-        BigNumber(stakeAccount.staked)
+        accountStakedMarketCoinAmount
           .multipliedBy(increasedPointRate)
           .plus(stakeAccount.points)
           .multipliedBy(spool.exchangeRateNumerator)
           .dividedBy(spool.exchangeRateDenominator)
       );
-      availableClaimCoin = availableClaimAmount.shiftedBy(-1 * coinDecimal);
+      availableClaimCoin = availableClaimAmount.shiftedBy(
+        -1 * spool.rewardCoinDecimal
+      );
     }
   }
 
@@ -298,12 +303,16 @@ export const getObligationAccount = async (
     ]),
   ];
   const obligationQuery = await query.queryObligation(obligationId);
+  const borrowIncentivePools = await query.getBorrowIncentivePools();
+  const borrowIncentiveAccounts =
+    await query.getBorrowIncentiveAccounts(obligationId);
   coinPrices = coinPrices || (await query.utils.getCoinPrices(assetCoinNames));
   coinAmounts =
     coinAmounts || (await query.getCoinAmounts(assetCoinNames, ownerAddress));
 
   const collaterals: ObligationAccount['collaterals'] = {};
   const debts: ObligationAccount['debts'] = {};
+  const borrowIncentives: ObligationAccount['borrowIncentives'] = {};
   let totalDepositedPools = 0;
   let totalDepositedValue = BigNumber(0);
   let totalBorrowCapacityValue = BigNumber(0);
@@ -419,6 +428,50 @@ export const getObligationAccount = async (
     }
   }
 
+  for (const [poolCoinName, borrowIncentiveAccount] of Object.entries(
+    borrowIncentiveAccounts
+  )) {
+    const coinName = poolCoinName as SupportBorrowIncentiveCoins;
+    const borrowIncentivePool = borrowIncentivePools[coinName];
+
+    let availableClaimAmount = BigNumber(0);
+    let availableClaimCoin = BigNumber(0);
+    if (borrowIncentivePool) {
+      const accountBorrowedAmount = BigNumber(borrowIncentiveAccount.amount);
+      const baseIndexRate = 1_000_000_000;
+      const increasedPointRate = borrowIncentivePool.currentPointIndex
+        ? BigNumber(
+            borrowIncentivePool.currentPointIndex - borrowIncentiveAccount.index
+          ).dividedBy(baseIndexRate)
+        : 1;
+      availableClaimAmount = availableClaimAmount.plus(
+        accountBorrowedAmount
+          .multipliedBy(increasedPointRate)
+          .plus(borrowIncentiveAccount.points)
+          .multipliedBy(borrowIncentivePool.exchangeRateNumerator)
+          .dividedBy(borrowIncentivePool.exchangeRateDenominator)
+      );
+      availableClaimCoin = availableClaimAmount.shiftedBy(
+        -1 * borrowIncentivePool.rewardCoinDecimal
+      );
+
+      if (availableClaimAmount.isGreaterThan(0)) {
+        borrowIncentives[coinName] = {
+          coinName: borrowIncentivePool.coinName,
+          coinType: borrowIncentivePool.coinType,
+          rewardCoinType: borrowIncentivePool.rewardCoinType,
+          symbol: borrowIncentivePool.symbol,
+          coinDecimal: borrowIncentivePool.coinDecimal,
+          rewardCoinDecimal: borrowIncentivePool.rewardCoinDecimal,
+          coinPrice: borrowIncentivePool.coinPrice,
+          rewardCoinPrice: borrowIncentivePool.rewardCoinPrice,
+          availableClaimAmount: availableClaimAmount.toNumber(),
+          availableClaimCoin: availableClaimCoin.toNumber(),
+        };
+      }
+    }
+  }
+
   let riskLevel =
     totalRequiredCollateralValue.isZero() &&
     totalBorrowedValueWithWeight.isZero()
@@ -472,6 +525,7 @@ export const getObligationAccount = async (
     totalBorrowedPools,
     collaterals,
     debts,
+    borrowIncentives,
   };
 
   for (const [collateralCoinName, obligationCollateral] of Object.entries(
@@ -500,10 +554,10 @@ export const getObligationAccount = async (
         .toNumber();
     }
   }
-  for (const [assetCoinName, obligationDebt] of Object.entries(
+  for (const [poolCoinName, obligationDebt] of Object.entries(
     obligationAccount.debts
   )) {
-    const marketPool = market.pools[assetCoinName as SupportPoolCoins];
+    const marketPool = market.pools[poolCoinName as SupportPoolCoins];
     if (marketPool) {
       const availableRepayAmount = BigNumber(
         obligationDebt.availableRepayAmount