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

package/dist/utils/util.d.ts

@@ -1,3 +1,16 @@
+import type { ScallopAddress } from '../models';
 import type { SupportAssetCoins, SupportCoins, SupportMarketCoins } from '../types';
 export declare const isMarketCoin: (coinName: SupportCoins) => coinName is SupportMarketCoins;
 export declare const parseAssetSymbol: (coinName: SupportAssetCoins) => string;
+/**
+ * Parse price from pyth price feed.
+ *
+ * @param feed  - Price feed object from pyth.
+ * @param address - Scallop address instance.
+ * @return Price Data inclue coin name, price, and publish time.
+ */
+export declare const parseDataFromPythPriceFeed: (feed: PriceFeed, address: ScallopAddress) => {
+    coinName: SupportAssetCoins;
+    price: number;
+    publishTime: number;
+};

package/package.json

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

package/src/builders/borrowIncentiveBuilder.ts

@@ -0,0 +1,257 @@
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui.js/utils';
+import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
+import { borrowIncentiveRewardCoins } from '../constants/enum';
+import { getObligations, getObligationLocked } from '../queries';
+import { requireSender } from '../utils';
+import type { SuiAddressArg } from '@scallop-io/sui-kit';
+import type { ScallopBuilder } from '../models';
+import type {
+  BorrowIncentiveIds,
+  GenerateBorrowIncentiveNormalMethod,
+  GenerateBorrowIncentiveQuickMethod,
+  SuiTxBlockWithBorrowIncentiveNormalMethods,
+  BorrowIncentiveTxBlock,
+  ScallopTxBlock,
+} from '../types';
+
+/**
+ * Check and get Obligation information from transaction block.
+ *
+ * @description
+ * If the obligation id is provided, direactly return it.
+ * If both obligation id and key is provided, direactly return them.
+ * Otherwise, automatically get obligation id and key from the sender.
+ *
+ * @param builder - Scallop builder instance.
+ * @param txBlock - TxBlock created by SuiKit.
+ * @param obligationId - Obligation id.
+ * @param obligationKey - Obligation key.
+ * @return Obligation id and key.
+ */
+const requireObligationInfo = async (
+  ...params: [
+    builder: ScallopBuilder,
+    txBlock: SuiKitTxBlock,
+    obligationId?: SuiAddressArg,
+    obligationKey?: SuiAddressArg,
+  ]
+) => {
+  const [builder, txBlock, obligationId, obligationKey] = params;
+  if (
+    params.length === 4 &&
+    obligationId &&
+    obligationKey &&
+    typeof obligationId === 'string'
+  ) {
+    const obligationLocked = await getObligationLocked(
+      builder.query,
+      obligationId
+    );
+    return { obligationId, obligationKey, obligationLocked };
+  }
+  const sender = requireSender(txBlock);
+  const obligations = await getObligations(builder.query, sender);
+  if (obligations.length === 0) {
+    throw new Error(`No obligation found for sender ${sender}`);
+  }
+  return {
+    obligationId: obligations[0].id,
+    obligationKey: obligations[0].keyId,
+    obligationLocked: obligations[0].locked,
+  };
+};
+
+/**
+ * Generate borrow incentive normal methods.
+ *
+ * @param builder - Scallop builder instance.
+ * @param txBlock - TxBlock created by SuiKit .
+ * @return Borrow incentive normal methods.
+ */
+const generateBorrowIncentiveNormalMethod: GenerateBorrowIncentiveNormalMethod =
+  ({ builder, txBlock }) => {
+    const borrowIncentiveIds: BorrowIncentiveIds = {
+      borrowIncentivePkg: builder.address.get('borrowIncentive.id'),
+      query: builder.address.get('borrowIncentive.query'),
+      incentivePools: builder.address.get('borrowIncentive.incentivePools'),
+      incentiveAccounts: builder.address.get(
+        'borrowIncentive.incentiveAccounts'
+      ),
+      obligationAccessStore: builder.address.get('core.obligationAccessStore'),
+    };
+    return {
+      stakeObligation: (obligationId, obligaionKey, coinName) => {
+        const rewardCoinName = borrowIncentiveRewardCoins[coinName];
+        const rewardType = builder.utils.parseCoinType(rewardCoinName);
+        txBlock.moveCall(
+          `${borrowIncentiveIds.borrowIncentivePkg}::user::stake`,
+          [
+            borrowIncentiveIds.incentivePools,
+            borrowIncentiveIds.incentiveAccounts,
+            obligaionKey,
+            obligationId,
+            borrowIncentiveIds.obligationAccessStore,
+            SUI_CLOCK_OBJECT_ID,
+          ],
+          [rewardType]
+        );
+      },
+      unstakeObligation: (obligationId, obligaionKey, coinName) => {
+        const rewardCoinName = borrowIncentiveRewardCoins[coinName];
+        const rewardType = builder.utils.parseCoinType(rewardCoinName);
+        txBlock.moveCall(
+          `${borrowIncentiveIds.borrowIncentivePkg}::user::unstake`,
+          [
+            borrowIncentiveIds.incentivePools,
+            borrowIncentiveIds.incentiveAccounts,
+            obligaionKey,
+            obligationId,
+            SUI_CLOCK_OBJECT_ID,
+          ],
+          [rewardType]
+        );
+      },
+      claimBorrowIncentive: (obligationId, obligaionKey, coinName) => {
+        const rewardCoinName = borrowIncentiveRewardCoins[coinName];
+        const rewardType = builder.utils.parseCoinType(rewardCoinName);
+        return txBlock.moveCall(
+          `${borrowIncentiveIds.borrowIncentivePkg}::user::redeem_rewards`,
+          [
+            borrowIncentiveIds.incentivePools,
+            borrowIncentiveIds.incentiveAccounts,
+            obligaionKey,
+            obligationId,
+            SUI_CLOCK_OBJECT_ID,
+          ],
+          [rewardType]
+        );
+      },
+    };
+  };
+
+/**
+ * Generate spool quick methods.
+ *
+ * @description
+ * The quick methods are the same as the normal methods, but they will automatically
+ * help users organize transaction blocks, include get stake account info, and transfer
+ * coins to the sender. So, they are all asynchronous methods.
+ *
+ * @param builder - Scallop builder instance.
+ * @param txBlock - TxBlock created by SuiKit .
+ * @return Spool quick methods.
+ */
+const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
+  ({ builder, txBlock }) => {
+    return {
+      stakeObligationQuick: async (coinName, obligation, obligationKey) => {
+        const {
+          obligationId: obligationArg,
+          obligationKey: obligationtKeyArg,
+          obligationLocked: obligationLocked,
+        } = await requireObligationInfo(
+          builder,
+          txBlock,
+          obligation,
+          obligationKey
+        );
+
+        const unstakeObligationBeforeStake =
+          !!txBlock.txBlock.blockData.transactions.find(
+            (txn) =>
+              txn.kind === 'MoveCall' &&
+              txn.target ===
+                `${builder.address.get('borrowIncentive.id')}::user::unstake`
+          );
+
+        if (!obligationLocked || unstakeObligationBeforeStake) {
+          txBlock.stakeObligation(obligationArg, obligationtKeyArg, coinName);
+        }
+      },
+      unstakeObligationQuick: async (coinName, obligation, obligationKey) => {
+        const {
+          obligationId: obligationArg,
+          obligationKey: obligationtKeyArg,
+          obligationLocked: obligationLocked,
+        } = await requireObligationInfo(
+          builder,
+          txBlock,
+          obligation,
+          obligationKey
+        );
+
+        if (obligationLocked) {
+          txBlock.unstakeObligation(obligationArg, obligationtKeyArg, coinName);
+        }
+      },
+      claimBorrowIncentiveQuick: async (
+        coinName,
+        obligation,
+        obligationKey
+      ) => {
+        const {
+          obligationId: obligationArg,
+          obligationKey: obligationtKeyArg,
+        } = await requireObligationInfo(
+          builder,
+          txBlock,
+          obligation,
+          obligationKey
+        );
+
+        return txBlock.claimBorrowIncentive(
+          obligationArg,
+          obligationtKeyArg,
+          coinName
+        );
+      },
+    };
+  };
+
+/**
+ * Create an enhanced transaction block instance for interaction with borrow incentive modules of the Scallop contract.
+ *
+ * @param builder - Scallop builder instance.
+ * @param initTxBlock - Scallop txBlock, txBlock created by SuiKit, or original transaction block.
+ * @return Scallop borrow incentive txBlock.
+ */
+export const newBorrowIncentiveTxBlock = (
+  builder: ScallopBuilder,
+  initTxBlock?: ScallopTxBlock | SuiKitTxBlock | TransactionBlock
+) => {
+  const txBlock =
+    initTxBlock instanceof TransactionBlock
+      ? new SuiKitTxBlock(initTxBlock)
+      : initTxBlock
+      ? initTxBlock
+      : new SuiKitTxBlock();
+
+  const normalMethod = generateBorrowIncentiveNormalMethod({
+    builder,
+    txBlock,
+  });
+
+  const normalTxBlock = new Proxy(txBlock, {
+    get: (target, prop) => {
+      if (prop in normalMethod) {
+        return Reflect.get(normalMethod, prop);
+      }
+      return Reflect.get(target, prop);
+    },
+  }) as SuiTxBlockWithBorrowIncentiveNormalMethods;
+
+  const quickMethod = generateBorrowIncentiveQuickMethod({
+    builder,
+    txBlock: normalTxBlock,
+  });
+
+  return new Proxy(normalTxBlock, {
+    get: (target, prop) => {
+      if (prop in quickMethod) {
+        return Reflect.get(quickMethod, prop);
+      }
+      return Reflect.get(target, prop);
+    },
+  }) as BorrowIncentiveTxBlock;
+};

package/src/builders/coreBuilder.ts

@@ -3,6 +3,7 @@ import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui.js/utils';
 import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
 import { getObligations } from '../queries';
 import { updateOracles } from './oracle';
+import { requireSender } from '../utils';
 import type { SuiAddressArg } from '@scallop-io/sui-kit';
 import type { ScallopBuilder } from '../models';
 import type {
@@ -14,20 +15,6 @@ import type {
   ScallopTxBlock,
 } from '../types';
 
-/**
- * Check and get the sender from the transaction block.
- *
- * @param txBlock - txBlock created by SuiKit.
- * @return Sender of transaction.
- */
-const requireSender = (txBlock: SuiKitTxBlock) => {
-  const sender = txBlock.blockData.sender;
-  if (!sender) {
-    throw new Error('Sender is required');
-  }
-  return sender;
-};
-
 /**
  * Check and get Obligation information from transaction block.
  *

package/src/builders/index.ts

@@ -2,6 +2,7 @@ import { TransactionBlock } from '@mysten/sui.js/transactions';
 import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
 import { newCoreTxBlock } from './coreBuilder';
 import { newSpoolTxBlock } from './spoolBuilder';
+import { newBorrowIncentiveTxBlock } from './borrowIncentiveBuilder';
 import type { ScallopBuilder } from '../models';
 import type { ScallopTxBlock } from '../types';
 
@@ -16,12 +17,18 @@ export const newScallopTxBlock = (
   builder: ScallopBuilder,
   initTxBlock?: ScallopTxBlock | SuiKitTxBlock | TransactionBlock
 ): ScallopTxBlock => {
-  const spoolTxBlock = newSpoolTxBlock(builder, initTxBlock);
+  const borrowIncentiveTxBlock = newBorrowIncentiveTxBlock(
+    builder,
+    initTxBlock
+  );
+  const spoolTxBlock = newSpoolTxBlock(builder, borrowIncentiveTxBlock);
   const coreTxBlock = newCoreTxBlock(builder, spoolTxBlock);
 
   return new Proxy(coreTxBlock, {
     get: (target, prop) => {
-      if (prop in spoolTxBlock) {
+      if (prop in borrowIncentiveTxBlock) {
+        return Reflect.get(borrowIncentiveTxBlock, prop);
+      } else if (prop in spoolTxBlock) {
         return Reflect.get(spoolTxBlock, prop);
       }
       return Reflect.get(target, prop);

package/src/builders/spoolBuilder.ts

@@ -1,8 +1,9 @@
 import { TransactionBlock } from '@mysten/sui.js/transactions';
 import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui.js/utils';
 import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
-import { rewardCoins } from '../constants/enum';
+import { spoolRewardCoins } from '../constants/enum';
 import { getStakeAccounts } from '../queries/spoolQuery';
+import { requireSender } from '../utils';
 import type { SuiAddressArg } from '@scallop-io/sui-kit';
 import type { TransactionResult } from '@mysten/sui.js/transactions';
 import type { ScallopBuilder } from '../models';
@@ -16,20 +17,6 @@ import type {
   ScallopTxBlock,
 } from '../types';
 
-/**
- * Check and get the sender from the transaction block.
- *
- * @param txBlock - TxBlock created by SuiKit.
- * @return Sender of transaction.
- */
-const requireSender = (txBlock: SuiKitTxBlock) => {
-  const sender = txBlock.blockData.sender;
-  if (!sender) {
-    throw new Error('Sender is required');
-  }
-  return sender;
-};
-
 /**
  * Check and get stake account id from transaction block.
  *
@@ -158,7 +145,7 @@ const generateSpoolNormalMethod: GenerateSpoolNormalMethod = ({
       );
       const marketCoinType =
         builder.utils.parseMarketCoinType(stakeMarketCoinName);
-      const rewardCoinName = rewardCoins[stakeMarketCoinName];
+      const rewardCoinName = spoolRewardCoins[stakeMarketCoinName];
       const rewardCoinType = builder.utils.parseCoinType(rewardCoinName);
       return txBlock.moveCall(
         `${spoolIds.spoolPkg}::user::redeem_rewards`,

package/src/constants/common.ts

@@ -35,8 +35,11 @@ export const SUPPORT_COLLATERALS = [
 
 export const SUPPORT_SPOOLS = ['ssui', 'susdc', 'susdt'] as const;
 
-export const SUPPORT_REWARD_POOLS = ['sui'] as const;
+export const SUPPORT_SPOOLS_REWARDS = ['sui'] as const;
 
+export const SUPPORT_BORROW_INCENTIVE_POOLS = ['sui', 'usdc'] as const;
+
+export const SUPPORT_BORROW_INCENTIVE_REWARDS = ['sui'] as const;
 export const SUPPORT_ORACLES = ['supra', 'switchboard', 'pyth'] as const;
 
 export const SUPPORT_PACKAGES = [

package/src/constants/enum.ts

@@ -3,7 +3,8 @@ import type {
   AssetCoins,
   MarketCoins,
   StakeMarketCoins,
-  RewardCoins,
+  StakeRewardCoins,
+  BorrowIncentiveRewardCoins,
   AssetCoinIds,
   WormholeCoinIds,
   VoloCoinIds,
@@ -68,12 +69,17 @@ export const stakeMarketCoins: StakeMarketCoins = {
   susdt: 'susdt',
 };
 
-export const rewardCoins: RewardCoins = {
+export const spoolRewardCoins: StakeRewardCoins = {
   ssui: 'sui',
   susdc: 'sui',
   susdt: 'sui',
 };
 
+export const borrowIncentiveRewardCoins: BorrowIncentiveRewardCoins = {
+  sui: 'sui',
+  usdc: 'sui',
+};
+
 export const coinIds: AssetCoinIds = {
   sui: '0x0000000000000000000000000000000000000000000000000000000000000002',
   eth: '0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5',

package/src/models/scallopAddress.ts

@@ -14,6 +14,7 @@ const EMPTY_ADDRESSES: AddressesInterface = {
     market: '',
     adminCap: '',
     coinDecimalsRegistry: '',
+    obligationAccessStore: '',
     coins: {
       btc: {
         id: '',
@@ -198,6 +199,13 @@ const EMPTY_ADDRESSES: AddressesInterface = {
       },
     },
   },
+  borrowIncentive: {
+    id: '',
+    adminCap: '',
+    query: '',
+    incentivePools: '',
+    incentiveAccounts: '',
+  },
 };
 
 /**

package/src/models/scallopClient.ts

@@ -17,6 +17,7 @@ import type {
   SupportAssetCoins,
   SupportStakeCoins,
   SupportStakeMarketCoins,
+  SupportBorrowIncentiveCoins,
   ScallopTxBlock,
 } from '../types';
 
@@ -189,8 +190,8 @@ export class ScallopClient {
    * @param stakeMarketCoinName - Support stake market coin.
    * @return Reward pool data.
    */
-  async getRewardPool(stakeMarketCoinName: SupportStakeMarketCoins) {
-    return await this.query.getRewardPool(stakeMarketCoinName);
+  async getStakeRewardPool(stakeMarketCoinName: SupportStakeMarketCoins) {
+    return await this.query.getStakeRewardPool(stakeMarketCoinName);
   }
 
   /* ==================== Core Method ==================== */
@@ -819,6 +820,107 @@ export class ScallopClient {
     }
   }
 
+  /* ==================== Borrow Incentive Method ==================== */
+
+  /**
+   * stake obligaion.
+   *
+   * @param sign - Decide to directly sign the transaction or return the transaction block.
+   * @param obligaionId - The obligation account object.
+   * @param obligaionKeyId - The obligation key account object.
+   * @param walletAddress - The wallet address of the owner.
+   * @return Transaction block response or transaction block
+   */
+  public async stakeObligation<S extends boolean>(
+    coinName: SupportBorrowIncentiveCoins,
+    obligaionId: string,
+    obligaionKeyId: string,
+    sign: S = true as S,
+    walletAddress?: string
+  ): Promise<ScallopClientFnReturnType<S>> {
+    const txBlock = this.builder.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+
+    await txBlock.stakeObligationQuick(coinName, obligaionId, obligaionKeyId);
+
+    if (sign) {
+      return (await this.suiKit.signAndSendTxn(
+        txBlock
+      )) as ScallopClientFnReturnType<S>;
+    } else {
+      return txBlock.txBlock as ScallopClientFnReturnType<S>;
+    }
+  }
+
+  /**
+   * unstake obligaion.
+   *
+   * @param sign - Decide to directly sign the transaction or return the transaction block.
+   * @param obligaionId - The obligation account object.
+   * @param obligaionKeyId - The obligation key account object.
+   * @param walletAddress - The wallet address of the owner.
+   * @return Transaction block response or transaction block
+   */
+  public async unstakeObligation<S extends boolean>(
+    coinName: SupportBorrowIncentiveCoins,
+    obligaionId: string,
+    obligaionKeyId: string,
+    sign: S = true as S,
+    walletAddress?: string
+  ): Promise<ScallopClientFnReturnType<S>> {
+    const txBlock = this.builder.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+
+    await txBlock.unstakeObligationQuick(coinName, obligaionId, obligaionKeyId);
+
+    if (sign) {
+      return (await this.suiKit.signAndSendTxn(
+        txBlock
+      )) as ScallopClientFnReturnType<S>;
+    } else {
+      return txBlock.txBlock as ScallopClientFnReturnType<S>;
+    }
+  }
+
+  /**
+   * unstake market coin from the specific spool.
+   *
+   * @param marketCoinName - Types of mak coin.
+   * @param amount - The amount of coins would deposit.
+   * @param sign - Decide to directly sign the transaction or return the transaction block.
+   * @param accountId - The stake account object.
+   * @param walletAddress - The wallet address of the owner.
+   * @return Transaction block response or transaction block
+   */
+  public async claimBorrowIncentive<S extends boolean>(
+    coinName: SupportBorrowIncentiveCoins,
+    obligaionId: string,
+    obligaionKeyId: string,
+    sign: S = true as S,
+    walletAddress?: string
+  ): Promise<ScallopClientFnReturnType<S>> {
+    const txBlock = this.builder.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+
+    const rewardCoin = await txBlock.claimBorrowIncentiveQuick(
+      coinName,
+      obligaionId,
+      obligaionKeyId
+    );
+    txBlock.transferObjects([rewardCoin], sender);
+
+    if (sign) {
+      return (await this.suiKit.signAndSendTxn(
+        txBlock
+      )) as ScallopClientFnReturnType<S>;
+    } else {
+      return txBlock.txBlock as ScallopClientFnReturnType<S>;
+    }
+  }
+
   /* ==================== Other Method ==================== */
 
   /**

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);
   }
 
   /**