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

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,166 @@
+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 = '0x' + 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

@@ -59,6 +59,17 @@ export const queryMarket = async (query: ScallopQuery) => {
   const collaterals: MarketCollaterals = {};
 
   for (const pool of marketData.pools) {
+    const coinType = '0x' + 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 +96,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 +115,19 @@ export const queryMarket = async (query: ScallopQuery) => {
   }
 
   for (const collateral of marketData.collaterals) {
+    const coinType = '0x' + 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 +144,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 +596,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/spoolQuery.ts

@@ -1,10 +1,10 @@
 import { normalizeStructTag } from '@mysten/sui.js/utils';
 import { SUPPORT_SPOOLS } from '../constants';
 import {
-  parseOriginStakePoolData,
-  calculateStakePoolData,
-  parseOriginRewardPoolData,
-  calculateRewardPoolData,
+  parseOriginSpoolData,
+  calculateSpoolData,
+  parseOriginSpoolRewardPoolData,
+  calculateSpoolRewardPoolData,
   isMarketCoin,
 } from '../utils';
 import type { SuiObjectResponse } from '@mysten/sui.js/client';
@@ -14,7 +14,7 @@ import type {
   Spools,
   Spool,
   StakePool,
-  RewardPool,
+  StakeRewardPool,
   StakeAccounts,
   SupportStakeMarketCoins,
   SupportStakeCoins,
@@ -64,18 +64,17 @@ export const getSpools = async (
  */
 export const getSpool = async (
   query: ScallopQuery,
-  stakeMarketCoinName: SupportStakeMarketCoins,
+  marketCoinName: SupportStakeMarketCoins,
   marketPool?: MarketPool
 ) => {
-  const stakeCoinName =
-    query.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName);
-  marketPool = marketPool || (await query.getMarketPool(stakeCoinName));
-  const poolId = query.address.get(`spool.pools.${stakeMarketCoinName}.id`);
+  const coinName = query.utils.parseCoinName<SupportStakeCoins>(marketCoinName);
+  marketPool = marketPool || (await query.getMarketPool(coinName));
+  const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
   const rewardPoolId = query.address.get(
-    `spool.pools.${stakeMarketCoinName}.rewardPoolId`
+    `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool: Spool | undefined = undefined;
-  const stakePoolObjectResponse = await query.suiKit.client().multiGetObjects({
+  const spoolObjectResponse = await query.suiKit.client().multiGetObjects({
     ids: [poolId, rewardPoolId],
     options: {
       showContent: true,
@@ -84,20 +83,20 @@ export const getSpool = async (
 
   if (
     marketPool &&
-    stakePoolObjectResponse[0].data &&
-    stakePoolObjectResponse[1].data
+    spoolObjectResponse[0].data &&
+    spoolObjectResponse[1].data
   ) {
-    const rewardCoin = query.utils.getRewardCoinName(stakeMarketCoinName);
+    const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
     const coinPrices = await query.utils.getCoinPrices([
-      stakeCoinName,
-      rewardCoin,
+      coinName,
+      rewardCoinName,
     ]);
 
-    const stakePoolObject = stakePoolObjectResponse[0].data;
-    const rewardPoolObject = stakePoolObjectResponse[1].data;
-    if (stakePoolObject.content && 'fields' in stakePoolObject.content) {
-      const fields = stakePoolObject.content.fields as any;
-      const parsedStakePoolData = parseOriginStakePoolData({
+    const spoolObject = spoolObjectResponse[0].data;
+    const rewardPoolObject = spoolObjectResponse[1].data;
+    if (spoolObject.content && 'fields' in spoolObject.content) {
+      const fields = spoolObject.content.fields as any;
+      const parsedSpoolData = parseOriginSpoolData({
         stakeType: fields.stake_type,
         maxDistributedPoint: fields.max_distributed_point,
         distributedPoint: fields.distributed_point,
@@ -110,19 +109,18 @@ export const getSpool = async (
         lastUpdate: fields.last_update,
       });
 
-      const stakeMarketCoinPrice =
-        (coinPrices?.[stakeCoinName] ?? 0) * marketPool.conversionRate;
-      const stakeMarketCoinDecimal =
-        query.utils.getCoinDecimal(stakeMarketCoinName);
-      const calculatedStakePoolData = calculateStakePoolData(
-        parsedStakePoolData,
-        stakeMarketCoinPrice,
-        stakeMarketCoinDecimal
+      const marketCoinPrice =
+        (coinPrices?.[coinName] ?? 0) * marketPool.conversionRate;
+      const marketCoinDecimal = query.utils.getCoinDecimal(marketCoinName);
+      const calculatedSpoolData = calculateSpoolData(
+        parsedSpoolData,
+        marketCoinPrice,
+        marketCoinDecimal
       );
 
       if (rewardPoolObject.content && 'fields' in rewardPoolObject.content) {
         const fields = rewardPoolObject.content.fields as any;
-        const parsedRewardPoolData = parseOriginRewardPoolData({
+        const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
           claimed_rewards: fields.claimed_rewards,
           exchange_rate_numerator: fields.exchange_rate_numerator,
           exchange_rate_denominator: fields.exchange_rate_denominator,
@@ -130,31 +128,38 @@ export const getSpool = async (
           spool_id: fields.spool_id,
         });
 
-        const rewardCoinPrice = coinPrices?.[rewardCoin] ?? 0;
-        const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoin);
+        const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+        const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
 
-        const calculatedRewardPoolData = calculateRewardPoolData(
-          parsedStakePoolData,
-          parsedRewardPoolData,
-          calculatedStakePoolData,
+        const calculatedRewardPoolData = calculateSpoolRewardPoolData(
+          parsedSpoolData,
+          parsedSpoolRewardPoolData,
+          calculatedSpoolData,
           rewardCoinPrice,
           rewardCoinDecimal
         );
 
         spool = {
-          marketCoinName: stakeMarketCoinName,
-          symbol: query.utils.parseSymbol(stakeMarketCoinName),
-          coinType: query.utils.parseCoinType(stakeCoinName),
-          marketCoinType: query.utils.parseMarketCoinType(stakeCoinName),
-          rewardCoinType: isMarketCoin(rewardCoin)
-            ? query.utils.parseMarketCoinType(rewardCoin)
-            : query.utils.parseCoinType(rewardCoin),
-          coinDecimal: query.utils.getCoinDecimal(stakeCoinName),
-          rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoin),
-          coinPrice: coinPrices?.[stakeCoinName] ?? 0,
-          marketCoinPrice: stakeMarketCoinPrice,
+          marketCoinName: marketCoinName,
+          symbol: query.utils.parseSymbol(marketCoinName),
+          coinType: query.utils.parseCoinType(coinName),
+          marketCoinType: query.utils.parseMarketCoinType(coinName),
+          rewardCoinType: isMarketCoin(rewardCoinName)
+            ? query.utils.parseMarketCoinType(rewardCoinName)
+            : query.utils.parseCoinType(rewardCoinName),
+          coinDecimal: query.utils.getCoinDecimal(coinName),
+          rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
+          coinPrice: coinPrices?.[coinName] ?? 0,
+          marketCoinPrice: marketCoinPrice,
           rewardCoinPrice: rewardCoinPrice,
-          ...calculatedStakePoolData,
+          maxPoint: parsedSpoolData.maxPoint,
+          distributedPoint: parsedSpoolData.distributedPoint,
+          maxStake: parsedSpoolData.maxStake,
+          ...calculatedSpoolData,
+          exchangeRateNumerator:
+            parsedSpoolRewardPoolData.exchangeRateNumerator,
+          exchangeRateDenominator:
+            parsedSpoolRewardPoolData.exchangeRateDenominator,
           ...calculatedRewardPoolData,
         };
       }
@@ -281,6 +286,10 @@ export const getStakeAccounts = async (
 /**
  * Get stake pool data.
  *
+ * @description
+ * For backward compatible, it is recommended to use `getSpool` method
+ * to get stake pool info in spool data.
+ *
  * @param query - The Scallop query instance.
  * @param marketCoinName - Specific support stake market coin name.
  * @return Stake pool data.
@@ -334,39 +343,46 @@ export const getStakePool = async (
 };
 
 /**
- * Get reward pool of the owner.
+ * Get stake reward pool of the owner.
+ *
+ * @description
+ * For backward compatible, it is recommended to use `getSpool` method
+ * to get reward info in spool data.
  *
  * @param query - The Scallop query instance.
  * @param marketCoinName - Specific support stake market coin name.
- * @return Reward pool.
+ * @return Stake reward pool.
  */
-export const getRewardPool = async (
+export const getStakeRewardPool = async (
   query: ScallopQuery,
   marketCoinName: SupportStakeMarketCoins
 ) => {
   const poolId = query.address.get(
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
-  let rewardPool: RewardPool | undefined = undefined;
-  const rewardPoolObjectResponse = await query.suiKit.client().getObject({
+  let stakeRewardPool: StakeRewardPool | undefined = undefined;
+  const stakeRewardPoolObjectResponse = await query.suiKit.client().getObject({
     id: poolId,
     options: {
       showContent: true,
       showType: true,
     },
   });
-  if (rewardPoolObjectResponse.data) {
-    const rewardPoolObject = rewardPoolObjectResponse.data;
-    const id = rewardPoolObject.objectId;
-    const type = rewardPoolObject.type!;
-    if (rewardPoolObject.content && 'fields' in rewardPoolObject.content) {
-      const fields = rewardPoolObject.content.fields as any;
+  if (stakeRewardPoolObjectResponse.data) {
+    const stakeRewardPoolObject = stakeRewardPoolObjectResponse.data;
+    const id = stakeRewardPoolObject.objectId;
+    const type = stakeRewardPoolObject.type!;
+    if (
+      stakeRewardPoolObject.content &&
+      'fields' in stakeRewardPoolObject.content
+    ) {
+      const fields = stakeRewardPoolObject.content.fields as any;
       const stakePoolId = String(fields.spool_id);
       const ratioNumerator = Number(fields.exchange_rate_numerator);
       const ratioDenominator = Number(fields.exchange_rate_denominator);
       const rewards = Number(fields.rewards);
       const claimedRewards = Number(fields.claimed_rewards);
-      rewardPool = {
+      stakeRewardPool = {
         id,
         type,
         stakePoolId,
@@ -377,5 +393,5 @@ export const getRewardPool = async (
       };
     }
   }
-  return rewardPool;
+  return stakeRewardPool;
 };

package/src/types/address.ts

@@ -13,6 +13,7 @@ export interface AddressesInterface {
     market: string;
     adminCap: string;
     coinDecimalsRegistry: string;
+    obligationAccessStore: string;
     coins: Partial<
       Record<
         SupportAssetCoins,
@@ -80,6 +81,13 @@ export interface AddressesInterface {
       >
     >;
   };
+  borrowIncentive: {
+    id: string;
+    adminCap: string;
+    query: string;
+    incentivePools: string;
+    incentiveAccounts: string;
+  };
 }
 
 type AddressPathsProps<T> = T extends string

package/src/types/builder/borrowIncentive.ts

@@ -0,0 +1,67 @@
+import type {
+  SuiTxBlock as SuiKitTxBlock,
+  SuiAddressArg,
+} from '@scallop-io/sui-kit';
+import type { TransactionResult } from '@mysten/sui.js/transactions';
+import type { ScallopBuilder } from '../../models';
+import type { SupportBorrowIncentiveCoins } from '../constant';
+
+export type BorrowIncentiveIds = {
+  borrowIncentivePkg: string;
+  query: string;
+  incentivePools: string;
+  incentiveAccounts: string;
+  obligationAccessStore: string;
+};
+
+export type BorrowIncentiveNormalMethods = {
+  stakeObligation: (
+    obligation: SuiAddressArg,
+    obligaionKey: SuiAddressArg,
+    coinName: SupportBorrowIncentiveCoins
+  ) => void;
+  unstakeObligation: (
+    obligation: SuiAddressArg,
+    obligaionKey: SuiAddressArg,
+    coinName: SupportBorrowIncentiveCoins
+  ) => void;
+  claimBorrowIncentive: (
+    obligation: SuiAddressArg,
+    obligaionKey: SuiAddressArg,
+    coinName: SupportBorrowIncentiveCoins
+  ) => TransactionResult;
+};
+
+export type BorrowIncentiveQuickMethods = {
+  stakeObligationQuick(
+    coinName: SupportBorrowIncentiveCoins,
+    obligation?: SuiAddressArg,
+    obligationKey?: SuiAddressArg
+  ): Promise<void>;
+  unstakeObligationQuick(
+    coinName: SupportBorrowIncentiveCoins,
+    obligation?: SuiAddressArg,
+    obligationKey?: SuiAddressArg
+  ): Promise<void>;
+  claimBorrowIncentiveQuick(
+    coinName: SupportBorrowIncentiveCoins,
+    obligation?: SuiAddressArg,
+    obligationKey?: SuiAddressArg
+  ): Promise<TransactionResult>;
+};
+
+export type SuiTxBlockWithBorrowIncentiveNormalMethods = SuiKitTxBlock &
+  BorrowIncentiveNormalMethods;
+
+export type BorrowIncentiveTxBlock =
+  SuiTxBlockWithBorrowIncentiveNormalMethods & BorrowIncentiveQuickMethods;
+
+export type GenerateBorrowIncentiveNormalMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiKitTxBlock;
+}) => BorrowIncentiveNormalMethods;
+
+export type GenerateBorrowIncentiveQuickMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiTxBlockWithBorrowIncentiveNormalMethods;
+}) => BorrowIncentiveQuickMethods;

package/src/types/builder/index.ts

@@ -1,7 +1,11 @@
 import type { CoreTxBlock } from './core';
 import type { SpoolTxBlock } from './spool';
+import type { BorrowIncentiveTxBlock } from './borrowIncentive';
 
 export type * from './core';
 export type * from './spool';
+export type * from './borrowIncentive';
 
-export type ScallopTxBlock = CoreTxBlock & SpoolTxBlock;
+export type ScallopTxBlock = CoreTxBlock &
+  SpoolTxBlock &
+  BorrowIncentiveTxBlock;

package/src/types/builder/spool.ts

@@ -38,7 +38,6 @@ export type SpoolQuickMethods = {
     stakeMarketCoinName: SupportStakeMarketCoins,
     stakeAccountId?: SuiAddressArg
   ): Promise<void>;
-
   unstakeQuick(
     amount: number,
     stakeMarketCoinName: SupportStakeMarketCoins,