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

package/dist/index.js

@@ -33,12 +33,14 @@ __export(src_exports, {
   ADDRESSES_ID: () => ADDRESSES_ID,
   API_BASE_URL: () => API_BASE_URL,
   PROTOCOL_OBJECT_ID: () => PROTOCOL_OBJECT_ID,
+  SUPPORT_BORROW_INCENTIVE_POOLS: () => SUPPORT_BORROW_INCENTIVE_POOLS,
+  SUPPORT_BORROW_INCENTIVE_REWARDS: () => SUPPORT_BORROW_INCENTIVE_REWARDS,
   SUPPORT_COLLATERALS: () => SUPPORT_COLLATERALS,
   SUPPORT_ORACLES: () => SUPPORT_ORACLES,
   SUPPORT_PACKAGES: () => SUPPORT_PACKAGES,
   SUPPORT_POOLS: () => SUPPORT_POOLS,
-  SUPPORT_REWARD_POOLS: () => SUPPORT_REWARD_POOLS,
   SUPPORT_SPOOLS: () => SUPPORT_SPOOLS,
+  SUPPORT_SPOOLS_REWARDS: () => SUPPORT_SPOOLS_REWARDS,
   Scallop: () => Scallop,
   ScallopAddress: () => ScallopAddress,
   ScallopBuilder: () => ScallopBuilder,
@@ -46,10 +48,11 @@ __export(src_exports, {
   ScallopQuery: () => ScallopQuery,
   ScallopUtils: () => ScallopUtils,
   assetCoins: () => assetCoins,
+  borrowIncentiveRewardCoins: () => borrowIncentiveRewardCoins,
   coinDecimals: () => coinDecimals,
   coinIds: () => coinIds,
   marketCoins: () => marketCoins,
-  rewardCoins: () => rewardCoins,
+  spoolRewardCoins: () => spoolRewardCoins,
   stakeMarketCoins: () => stakeMarketCoins,
   voloCoinIds: () => voloCoinIds,
   wormholeCoinIds: () => wormholeCoinIds
@@ -87,7 +90,9 @@ var SUPPORT_COLLATERALS = [
   "vsui"
 ];
 var SUPPORT_SPOOLS = ["ssui", "susdc", "susdt"];
-var SUPPORT_REWARD_POOLS = ["sui"];
+var SUPPORT_SPOOLS_REWARDS = ["sui"];
+var SUPPORT_BORROW_INCENTIVE_POOLS = ["sui", "usdc"];
+var SUPPORT_BORROW_INCENTIVE_REWARDS = ["sui"];
 var SUPPORT_ORACLES = ["supra", "switchboard", "pyth"];
 var SUPPORT_PACKAGES = [
   "coinDecimalsRegistry",
@@ -160,11 +165,15 @@ var stakeMarketCoins = {
   susdc: "susdc",
   susdt: "susdt"
 };
-var rewardCoins = {
+var spoolRewardCoins = {
   ssui: "sui",
   susdc: "sui",
   susdt: "sui"
 };
+var borrowIncentiveRewardCoins = {
+  sui: "sui",
+  usdc: "sui"
+};
 var coinIds = {
   sui: "0x0000000000000000000000000000000000000000000000000000000000000002",
   eth: "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5",
@@ -191,7 +200,7 @@ var voloCoinIds = {
 };
 
 // src/models/scallop.ts
-var import_sui_kit8 = require("@scallop-io/sui-kit");
+var import_sui_kit10 = require("@scallop-io/sui-kit");
 
 // src/models/scallopAddress.ts
 var import_axios = __toESM(require("axios"));
@@ -202,6 +211,7 @@ var EMPTY_ADDRESSES = {
     market: "",
     adminCap: "",
     coinDecimalsRegistry: "",
+    obligationAccessStore: "",
     coins: {
       btc: {
         id: "",
@@ -385,6 +395,13 @@ var EMPTY_ADDRESSES = {
         rewardPoolId: ""
       }
     }
+  },
+  borrowIncentive: {
+    id: "",
+    adminCap: "",
+    query: "",
+    incentivePools: "",
+    incentiveAccounts: ""
   }
 };
 var ScallopAddress = class {
@@ -688,43 +705,33 @@ var ScallopAddress = class {
 };
 
 // src/models/scallopClient.ts
-var import_utils11 = require("@mysten/sui.js/utils");
-var import_sui_kit7 = require("@scallop-io/sui-kit");
+var import_utils17 = require("@mysten/sui.js/utils");
+var import_sui_kit9 = require("@scallop-io/sui-kit");
 
 // src/models/scallopUtils.ts
-var import_utils5 = require("@mysten/sui.js/utils");
-var import_sui_kit3 = require("@scallop-io/sui-kit");
+var import_utils7 = require("@mysten/sui.js/utils");
+var import_sui_kit4 = require("@scallop-io/sui-kit");
 var import_pyth_sui_js = require("@pythnetwork/pyth-sui-js");
 
 // src/models/scallopQuery.ts
-var import_sui_kit2 = require("@scallop-io/sui-kit");
+var import_sui_kit3 = require("@scallop-io/sui-kit");
 
 // src/queries/coreQuery.ts
 var import_sui_kit = require("@scallop-io/sui-kit");
 var import_bignumber2 = __toESM(require("bignumber.js"));
 
-// src/utils/oracle.ts
-var parseDataFromPythPriceFeed = (feed, address) => {
-  const assetCoinNames = [
-    .../* @__PURE__ */ new Set([...SUPPORT_POOLS, ...SUPPORT_COLLATERALS])
-  ];
-  const assetCoinName = assetCoinNames.find((assetCoinName2) => {
-    return address.get(`core.coins.${assetCoinName2}.oracle.pyth.feed`) === feed.id;
-  });
-  if (assetCoinName) {
-    const price = feed.price.price * 10 ** feed.price.expo;
-    return {
-      coinName: assetCoinName,
-      price,
-      publishTime: Number(feed.price.publishTime) * 10 ** 3
-    };
-  } else {
-    throw new Error("Invalid feed id");
+// src/utils/builder.ts
+var requireSender = (txBlock) => {
+  const sender = txBlock.blockData.sender;
+  if (!sender) {
+    throw new Error("Sender is required");
   }
+  return sender;
 };
 
 // src/utils/query.ts
 var import_bignumber = __toESM(require("bignumber.js"));
+var import_utils = require("@mysten/sui.js/utils");
 var parseOriginMarketPoolData = (originMarketPoolData) => {
   return {
     coinType: "0x" + originMarketPoolData.type.name,
@@ -851,48 +858,48 @@ var calculateMarketCollateralData = (utils, parsedMarketCollateralData) => {
     depositCoin: depositCoin.toNumber()
   };
 };
-var parseOriginStakePoolData = (originStakePoolData) => {
+var parseOriginSpoolData = (originSpoolData) => {
   return {
-    stakeType: "0x" + originStakePoolData.stakeType.fields.name,
-    maxPoint: Number(originStakePoolData.maxDistributedPoint),
-    distributedPoint: Number(originStakePoolData.distributedPoint),
-    pointPerPeriod: Number(originStakePoolData.distributedPointPerPeriod),
-    period: Number(originStakePoolData.pointDistributionTime),
-    maxStake: Number(originStakePoolData.maxStake),
-    staked: Number(originStakePoolData.stakes),
-    index: Number(originStakePoolData.index),
-    createdAt: Number(originStakePoolData.createdAt),
-    lastUpdate: Number(originStakePoolData.lastUpdate)
+    stakeType: "0x" + originSpoolData.stakeType.fields.name,
+    maxPoint: Number(originSpoolData.maxDistributedPoint),
+    distributedPoint: Number(originSpoolData.distributedPoint),
+    pointPerPeriod: Number(originSpoolData.distributedPointPerPeriod),
+    period: Number(originSpoolData.pointDistributionTime),
+    maxStake: Number(originSpoolData.maxStake),
+    staked: Number(originSpoolData.stakes),
+    index: Number(originSpoolData.index),
+    createdAt: Number(originSpoolData.createdAt),
+    lastUpdate: Number(originSpoolData.lastUpdate)
   };
 };
-var calculateStakePoolData = (parsedStakePoolData, stakeMarketCoinPrice, stakeMarketCoinDecimal) => {
+var calculateSpoolData = (parsedSpoolData, stakeMarketCoinPrice, stakeMarketCoinDecimal) => {
   const baseIndexRate = 1e9;
   const distributedPointPerSec = (0, import_bignumber.default)(
-    parsedStakePoolData.pointPerPeriod
-  ).dividedBy(parsedStakePoolData.period);
-  const pointPerSec = (0, import_bignumber.default)(parsedStakePoolData.pointPerPeriod).dividedBy(
-    parsedStakePoolData.period
+    parsedSpoolData.pointPerPeriod
+  ).dividedBy(parsedSpoolData.period);
+  const pointPerSec = (0, import_bignumber.default)(parsedSpoolData.pointPerPeriod).dividedBy(
+    parsedSpoolData.period
   );
-  const remainingPeriod = (0, import_bignumber.default)(parsedStakePoolData.maxPoint).minus(parsedStakePoolData.distributedPoint).dividedBy(pointPerSec);
-  const startDate = parsedStakePoolData.createdAt;
-  const endDate = remainingPeriod.plus(parsedStakePoolData.lastUpdate).integerValue().toNumber();
+  const remainingPeriod = (0, import_bignumber.default)(parsedSpoolData.maxPoint).minus(parsedSpoolData.distributedPoint).dividedBy(pointPerSec);
+  const startDate = parsedSpoolData.createdAt;
+  const endDate = remainingPeriod.plus(parsedSpoolData.lastUpdate).integerValue().toNumber();
   const timeDelta = (0, import_bignumber.default)(
-    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedStakePoolData.lastUpdate
-  ).dividedBy(parsedStakePoolData.period).toFixed(0);
-  const remainingPoints = (0, import_bignumber.default)(parsedStakePoolData.maxPoint).minus(
-    parsedStakePoolData.distributedPoint
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedSpoolData.lastUpdate
+  ).dividedBy(parsedSpoolData.period).toFixed(0);
+  const remainingPoints = (0, import_bignumber.default)(parsedSpoolData.maxPoint).minus(
+    parsedSpoolData.distributedPoint
   );
   const accumulatedPoints = import_bignumber.default.minimum(
-    (0, import_bignumber.default)(timeDelta).multipliedBy(parsedStakePoolData.pointPerPeriod),
+    (0, import_bignumber.default)(timeDelta).multipliedBy(parsedSpoolData.pointPerPeriod),
     remainingPoints
   );
-  const currentPointIndex = (0, import_bignumber.default)(parsedStakePoolData.index).plus(
-    accumulatedPoints.dividedBy(parsedStakePoolData.staked).isFinite() ? (0, import_bignumber.default)(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedStakePoolData.staked) : 0
+  const currentPointIndex = (0, import_bignumber.default)(parsedSpoolData.index).plus(
+    accumulatedPoints.dividedBy(parsedSpoolData.staked).isFinite() ? (0, import_bignumber.default)(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedSpoolData.staked) : 0
   );
   const currentTotalDistributedPoint = (0, import_bignumber.default)(
-    parsedStakePoolData.distributedPoint
+    parsedSpoolData.distributedPoint
   ).plus(accumulatedPoints);
-  const stakedAmount = (0, import_bignumber.default)(parsedStakePoolData.staked);
+  const stakedAmount = (0, import_bignumber.default)(parsedSpoolData.staked);
   const stakedCoin = stakedAmount.shiftedBy(-1 * stakeMarketCoinDecimal);
   const stakedValue = stakedCoin.multipliedBy(stakeMarketCoinPrice);
   return {
@@ -907,35 +914,39 @@ var calculateStakePoolData = (parsedStakePoolData, stakeMarketCoinPrice, stakeMa
     stakedValue: stakedValue.toNumber()
   };
 };
-var parseOriginRewardPoolData = (originRewardPoolData) => {
+var parseOriginSpoolRewardPoolData = (originSpoolRewardPoolData) => {
   return {
-    claimedRewards: Number(originRewardPoolData.claimed_rewards),
-    exchangeRateNumerator: Number(originRewardPoolData.exchange_rate_numerator),
+    claimedRewards: Number(originSpoolRewardPoolData.claimed_rewards),
+    exchangeRateNumerator: Number(
+      originSpoolRewardPoolData.exchange_rate_numerator
+    ),
     exchangeRateDenominator: Number(
-      originRewardPoolData.exchange_rate_denominator
+      originSpoolRewardPoolData.exchange_rate_denominator
     ),
-    rewards: Number(originRewardPoolData.rewards),
-    spoolId: String(originRewardPoolData.spool_id)
+    rewards: Number(originSpoolRewardPoolData.rewards),
+    spoolId: String(originSpoolRewardPoolData.spool_id)
   };
 };
-var calculateRewardPoolData = (parsedStakePoolData, parsedRewardPoolData, calculatedStakePoolData, rewardCoinPrice, rewardCoinDecimal) => {
+var calculateSpoolRewardPoolData = (parsedSpoolData, parsedSpoolRewardPoolData, calculatedSpoolData, rewardCoinPrice, rewardCoinDecimal) => {
   const rateYearFactor = 365 * 24 * 60 * 60;
-  const rewardPerSec = (0, import_bignumber.default)(calculatedStakePoolData.distributedPointPerSec).multipliedBy(parsedRewardPoolData.exchangeRateNumerator).dividedBy(parsedRewardPoolData.exchangeRateDenominator);
-  const totalRewardAmount = (0, import_bignumber.default)(parsedStakePoolData.maxPoint).multipliedBy(parsedRewardPoolData.exchangeRateNumerator).dividedBy(parsedRewardPoolData.exchangeRateDenominator);
+  const rewardPerSec = (0, import_bignumber.default)(calculatedSpoolData.distributedPointPerSec).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
+  const totalRewardAmount = (0, import_bignumber.default)(parsedSpoolData.maxPoint).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
   const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
   const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
-  const remaindRewardAmount = (0, import_bignumber.default)(parsedRewardPoolData.rewards);
+  const remaindRewardAmount = (0, import_bignumber.default)(parsedSpoolRewardPoolData.rewards);
   const remaindRewardCoin = remaindRewardAmount.shiftedBy(
     -1 * rewardCoinDecimal
   );
   const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
-  const claimedRewardAmount = (0, import_bignumber.default)(parsedRewardPoolData.claimedRewards);
+  const claimedRewardAmount = (0, import_bignumber.default)(
+    parsedSpoolRewardPoolData.claimedRewards
+  );
   const claimedRewardCoin = claimedRewardAmount.shiftedBy(
     -1 * rewardCoinDecimal
   );
   const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
   const rewardValueForYear = (0, import_bignumber.default)(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
-  const rewardRate = rewardValueForYear.dividedBy(calculatedStakePoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedStakePoolData.stakedValue).toNumber() : Infinity;
+  const rewardRate = rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).toNumber() : Infinity;
   return {
     rewardApr: rewardRate,
     totalRewardAmount: totalRewardAmount.toNumber(),
@@ -947,9 +958,133 @@ var calculateRewardPoolData = (parsedStakePoolData, parsedRewardPoolData, calcul
     claimedRewardAmount: claimedRewardAmount.toNumber(),
     claimedRewardCoin: claimedRewardCoin.toNumber(),
     claimedRewardValue: claimedRewardValue.toNumber(),
-    rewardPerSec: rewardPerSec.toNumber(),
-    exchangeRateNumerator: parsedRewardPoolData.exchangeRateNumerator,
-    exchangeRateDenominator: parsedRewardPoolData.exchangeRateDenominator
+    rewardPerSec: rewardPerSec.toNumber()
+  };
+};
+var parseOriginBorrowIncentivePoolData = (originBorrowIncentivePoolData) => {
+  return {
+    poolType: (0, import_utils.normalizeStructTag)(originBorrowIncentivePoolData.pool_type.name),
+    maxPoint: Number(originBorrowIncentivePoolData.max_distributed_point),
+    distributedPoint: Number(originBorrowIncentivePoolData.distributed_point),
+    pointPerPeriod: Number(
+      originBorrowIncentivePoolData.distributed_point_per_period
+    ),
+    period: Number(originBorrowIncentivePoolData.point_distribution_time),
+    maxStake: Number(originBorrowIncentivePoolData.max_stakes),
+    staked: Number(originBorrowIncentivePoolData.stakes),
+    index: Number(originBorrowIncentivePoolData.index),
+    createdAt: Number(originBorrowIncentivePoolData.created_at),
+    lastUpdate: Number(originBorrowIncentivePoolData.last_update)
+  };
+};
+var calculateBorrowIncentivePoolData = (parsedBorrowIncentivePoolData, borrowIncentiveCoinPrice, borrowIncentiveCoinDecimal) => {
+  const baseIndexRate = 1e9;
+  const distributedPointPerSec = (0, import_bignumber.default)(
+    parsedBorrowIncentivePoolData.pointPerPeriod
+  ).dividedBy(parsedBorrowIncentivePoolData.period);
+  const pointPerSec = (0, import_bignumber.default)(
+    parsedBorrowIncentivePoolData.pointPerPeriod
+  ).dividedBy(parsedBorrowIncentivePoolData.period);
+  const remainingPeriod = (0, import_bignumber.default)(parsedBorrowIncentivePoolData.maxPoint).minus(parsedBorrowIncentivePoolData.distributedPoint).dividedBy(pointPerSec);
+  const startDate = parsedBorrowIncentivePoolData.createdAt;
+  const endDate = remainingPeriod.plus(parsedBorrowIncentivePoolData.lastUpdate).integerValue().toNumber();
+  const timeDelta = (0, import_bignumber.default)(
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedBorrowIncentivePoolData.lastUpdate
+  ).dividedBy(parsedBorrowIncentivePoolData.period).toFixed(0);
+  const remainingPoints = (0, import_bignumber.default)(
+    parsedBorrowIncentivePoolData.maxPoint
+  ).minus(parsedBorrowIncentivePoolData.distributedPoint);
+  const accumulatedPoints = import_bignumber.default.minimum(
+    (0, import_bignumber.default)(timeDelta).multipliedBy(
+      parsedBorrowIncentivePoolData.pointPerPeriod
+    ),
+    remainingPoints
+  );
+  const currentPointIndex = (0, import_bignumber.default)(parsedBorrowIncentivePoolData.index).plus(
+    accumulatedPoints.dividedBy(parsedBorrowIncentivePoolData.staked).isFinite() ? (0, import_bignumber.default)(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedBorrowIncentivePoolData.staked) : 0
+  );
+  const currentTotalDistributedPoint = (0, import_bignumber.default)(
+    parsedBorrowIncentivePoolData.distributedPoint
+  ).plus(accumulatedPoints);
+  const stakedAmount = (0, import_bignumber.default)(parsedBorrowIncentivePoolData.staked);
+  const stakedCoin = stakedAmount.shiftedBy(-1 * borrowIncentiveCoinDecimal);
+  const stakedValue = stakedCoin.multipliedBy(borrowIncentiveCoinPrice);
+  return {
+    distributedPointPerSec: distributedPointPerSec.toNumber(),
+    accumulatedPoints: accumulatedPoints.toNumber(),
+    currentPointIndex: currentPointIndex.toNumber(),
+    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
+    startDate: new Date(startDate * 1e3),
+    endDate: new Date(endDate * 1e3),
+    stakedAmount: stakedAmount.toNumber(),
+    stakedCoin: stakedCoin.toNumber(),
+    stakedValue: stakedValue.toNumber()
+  };
+};
+var parseOriginBorrowIncentiveRewardPoolData = (originBorrowIncentiveRewardPoolData) => {
+  return {
+    rewardType: (0, import_utils.normalizeStructTag)(
+      originBorrowIncentiveRewardPoolData.reward_type.name
+    ),
+    claimedRewards: Number(originBorrowIncentiveRewardPoolData.claimed_rewards),
+    exchangeRateNumerator: Number(
+      originBorrowIncentiveRewardPoolData.exchange_rate_numerator
+    ),
+    exchangeRateDenominator: Number(
+      originBorrowIncentiveRewardPoolData.exchange_rate_denominator
+    ),
+    remainingRewards: Number(
+      originBorrowIncentiveRewardPoolData.remaining_reward
+    )
+  };
+};
+var calculateBorrowIncentiveRewardPoolData = (parsedBorrowIncentivePoolData, parsedBorrowIncentiveRewardPoolData, calculatedBorrowIncentivePoolData, rewardCoinPrice, rewardCoinDecimal) => {
+  const rateYearFactor = 365 * 24 * 60 * 60;
+  const rewardPerSec = (0, import_bignumber.default)(
+    calculatedBorrowIncentivePoolData.distributedPointPerSec
+  ).multipliedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator).dividedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator);
+  const totalRewardAmount = (0, import_bignumber.default)(parsedBorrowIncentivePoolData.maxPoint).multipliedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator).dividedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator);
+  const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
+  const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
+  const remaindRewardAmount = (0, import_bignumber.default)(
+    parsedBorrowIncentiveRewardPoolData.remainingRewards
+  );
+  const remaindRewardCoin = remaindRewardAmount.shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
+  const claimedRewardAmount = (0, import_bignumber.default)(
+    parsedBorrowIncentiveRewardPoolData.claimedRewards
+  );
+  const claimedRewardCoin = claimedRewardAmount.shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
+  const rewardValueForYear = (0, import_bignumber.default)(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
+  const rewardRate = rewardValueForYear.dividedBy(calculatedBorrowIncentivePoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedBorrowIncentivePoolData.stakedValue).toNumber() : Infinity;
+  return {
+    rewardApr: rewardRate,
+    totalRewardAmount: totalRewardAmount.toNumber(),
+    totalRewardCoin: totalRewardCoin.toNumber(),
+    totalRewardValue: totalRewardValue.toNumber(),
+    remaindRewardAmount: remaindRewardAmount.toNumber(),
+    remaindRewardCoin: remaindRewardCoin.toNumber(),
+    remaindRewardValue: remaindRewardValue.toNumber(),
+    claimedRewardAmount: claimedRewardAmount.toNumber(),
+    claimedRewardCoin: claimedRewardCoin.toNumber(),
+    claimedRewardValue: claimedRewardValue.toNumber(),
+    rewardPerSec: rewardPerSec.toNumber()
+  };
+};
+var parseOriginBorrowIncentiveAccountData = (originBorrowIncentiveAccountData) => {
+  return {
+    poolType: (0, import_utils.normalizeStructTag)(
+      originBorrowIncentiveAccountData.pool_type.name
+    ),
+    amount: Number(originBorrowIncentiveAccountData.amount),
+    index: Number(originBorrowIncentiveAccountData.index),
+    points: Number(originBorrowIncentiveAccountData.points),
+    totalPoints: Number(originBorrowIncentiveAccountData.total_points)
   };
 };
 var minBigNumber = (...args) => {
@@ -967,7 +1102,7 @@ var isMarketCoin = (coinName) => {
     .../* @__PURE__ */ new Set([
       ...SUPPORT_POOLS,
       ...SUPPORT_COLLATERALS,
-      ...SUPPORT_REWARD_POOLS
+      ...SUPPORT_SPOOLS_REWARDS
     ])
   ].includes(assetCoinName);
 };
@@ -983,6 +1118,24 @@ var parseAssetSymbol = (coinName) => {
       return coinName.toUpperCase();
   }
 };
+var parseDataFromPythPriceFeed = (feed, address) => {
+  const assetCoinNames = [
+    .../* @__PURE__ */ new Set([...SUPPORT_POOLS, ...SUPPORT_COLLATERALS])
+  ];
+  const assetCoinName = assetCoinNames.find((assetCoinName2) => {
+    return address.get(`core.coins.${assetCoinName2}.oracle.pyth.feed`) === feed.id;
+  });
+  if (assetCoinName) {
+    const price = feed.price.price * 10 ** feed.price.expo;
+    return {
+      coinName: assetCoinName,
+      price,
+      publishTime: Number(feed.price.publishTime) * 10 ** 3
+    };
+  } else {
+    throw new Error("Invalid feed id");
+  }
+};
 
 // src/queries/coreQuery.ts
 var queryMarket = async (query) => {
@@ -996,6 +1149,12 @@ var queryMarket = async (query) => {
   const pools = {};
   const collaterals = {};
   for (const pool of marketData.pools) {
+    const coinType = "0x" + pool.type.name;
+    const poolCoinName = query.utils.parseCoinNameFromType(coinType);
+    const coinPrice = (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
+    if (!SUPPORT_POOLS.includes(poolCoinName)) {
+      continue;
+    }
     const parsedMarketPoolData = parseOriginMarketPoolData({
       type: pool.type,
       maxBorrowRate: pool.maxBorrowRate,
@@ -1020,9 +1179,6 @@ var queryMarket = async (query) => {
       query.utils,
       parsedMarketPoolData
     );
-    const coinType = "0x" + pool.type.name;
-    const poolCoinName = query.utils.parseCoinNameFromType(coinType);
-    const coinPrice = (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
     pools[poolCoinName] = {
       coinName: poolCoinName,
       symbol: query.utils.parseSymbol(poolCoinName),
@@ -1041,6 +1197,12 @@ var queryMarket = async (query) => {
     };
   }
   for (const collateral of marketData.collaterals) {
+    const coinType = "0x" + collateral.type.name;
+    const collateralCoinName = query.utils.parseCoinNameFromType(coinType);
+    const coinPrice = (await query.utils.getCoinPrices([collateralCoinName]))?.[collateralCoinName] ?? 0;
+    if (!SUPPORT_COLLATERALS.includes(collateralCoinName)) {
+      continue;
+    }
     const parsedMarketCollateralData = parseOriginMarketCollateralData({
       type: collateral.type,
       collateralFactor: collateral.collateralFactor,
@@ -1055,9 +1217,6 @@ var queryMarket = async (query) => {
       query.utils,
       parsedMarketCollateralData
     );
-    const coinType = "0x" + collateral.type.name;
-    const collateralCoinName = query.utils.parseCoinNameFromType(coinType);
-    const coinPrice = (await query.utils.getCoinPrices([collateralCoinName]))?.[collateralCoinName] ?? 0;
     collaterals[collateralCoinName] = {
       coinName: collateralCoinName,
       symbol: query.utils.parseSymbol(collateralCoinName),
@@ -1344,11 +1503,27 @@ var getObligations = async (query, ownerAddress) => {
     if (keyObject.content && "fields" in keyObject.content) {
       const fields = keyObject.content.fields;
       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;
 };
+var getObligationLocked = async (query, obligationId) => {
+  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;
+};
 var queryObligation = async (query, obligationId) => {
   const packageId = query.address.get("core.packages.query.id");
   const queryTarget = `${packageId}::obligation_query::obligation_data`;
@@ -1523,7 +1698,7 @@ var getMarketCoinAmount = async (query, marketCoinName, ownerAddress) => {
 };
 
 // src/queries/spoolQuery.ts
-var import_utils2 = require("@mysten/sui.js/utils");
+var import_utils3 = require("@mysten/sui.js/utils");
 var getSpools = async (query, stakeMarketCoinNames) => {
   stakeMarketCoinNames = stakeMarketCoinNames || [...SUPPORT_SPOOLS];
   const stakeCoinNames = stakeMarketCoinNames.map(
@@ -1544,31 +1719,31 @@ var getSpools = async (query, stakeMarketCoinNames) => {
   }
   return spools;
 };
-var getSpool = async (query, stakeMarketCoinName, marketPool) => {
-  const stakeCoinName = query.utils.parseCoinName(stakeMarketCoinName);
-  marketPool = marketPool || await query.getMarketPool(stakeCoinName);
-  const poolId = query.address.get(`spool.pools.${stakeMarketCoinName}.id`);
+var getSpool = async (query, marketCoinName, marketPool) => {
+  const coinName = query.utils.parseCoinName(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 = void 0;
-  const stakePoolObjectResponse = await query.suiKit.client().multiGetObjects({
+  const spoolObjectResponse = await query.suiKit.client().multiGetObjects({
     ids: [poolId, rewardPoolId],
     options: {
       showContent: true
     }
   });
-  if (marketPool && stakePoolObjectResponse[0].data && stakePoolObjectResponse[1].data) {
-    const rewardCoin = query.utils.getRewardCoinName(stakeMarketCoinName);
+  if (marketPool && spoolObjectResponse[0].data && spoolObjectResponse[1].data) {
+    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;
-      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;
+      const parsedSpoolData = parseOriginSpoolData({
         stakeType: fields.stake_type,
         maxDistributedPoint: fields.max_distributed_point,
         distributedPoint: fields.distributed_point,
@@ -1580,43 +1755,48 @@ var getSpool = async (query, stakeMarketCoinName, marketPool) => {
         createdAt: fields.created_at,
         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 fields2 = rewardPoolObject.content.fields;
-        const parsedRewardPoolData = parseOriginRewardPoolData({
+        const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
           claimed_rewards: fields2.claimed_rewards,
           exchange_rate_numerator: fields2.exchange_rate_numerator,
           exchange_rate_denominator: fields2.exchange_rate_denominator,
           rewards: fields2.rewards,
           spool_id: fields2.spool_id
         });
-        const rewardCoinPrice = coinPrices?.[rewardCoin] ?? 0;
-        const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoin);
-        const calculatedRewardPoolData = calculateRewardPoolData(
-          parsedStakePoolData,
-          parsedRewardPoolData,
-          calculatedStakePoolData,
+        const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+        const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+        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,
+          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,
           rewardCoinPrice,
-          ...calculatedStakePoolData,
+          maxPoint: parsedSpoolData.maxPoint,
+          distributedPoint: parsedSpoolData.distributedPoint,
+          maxStake: parsedSpoolData.maxStake,
+          ...calculatedSpoolData,
+          exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
+          exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
           ...calculatedRewardPoolData
         };
       }
@@ -1674,7 +1854,7 @@ var getStakeAccounts = async (query, ownerAddress) => {
       const index = Number(fields.index);
       const points = Number(fields.points);
       const totalPoints = Number(fields.total_points);
-      if ((0, import_utils2.normalizeStructTag)(type) === stakeMarketCoinTypes.ssui) {
+      if ((0, import_utils3.normalizeStructTag)(type) === stakeMarketCoinTypes.ssui) {
         stakeAccounts.ssui.push({
           id,
           type,
@@ -1685,7 +1865,7 @@ var getStakeAccounts = async (query, ownerAddress) => {
           points,
           totalPoints
         });
-      } else if ((0, import_utils2.normalizeStructTag)(type) === stakeMarketCoinTypes.susdc) {
+      } else if ((0, import_utils3.normalizeStructTag)(type) === stakeMarketCoinTypes.susdc) {
         stakeAccounts.susdc.push({
           id,
           type,
@@ -1696,7 +1876,7 @@ var getStakeAccounts = async (query, ownerAddress) => {
           points,
           totalPoints
         });
-      } else if ((0, import_utils2.normalizeStructTag)(type) === stakeMarketCoinTypes.susdt) {
+      } else if ((0, import_utils3.normalizeStructTag)(type) === stakeMarketCoinTypes.susdt) {
         stakeAccounts.susdt.push({
           id,
           type,
@@ -1756,30 +1936,30 @@ var getStakePool = async (query, marketCoinName) => {
   }
   return stakePool;
 };
-var getRewardPool = async (query, marketCoinName) => {
+var getStakeRewardPool = async (query, marketCoinName) => {
   const poolId = query.address.get(
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
-  let rewardPool = void 0;
-  const rewardPoolObjectResponse = await query.suiKit.client().getObject({
+  let stakeRewardPool = void 0;
+  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;
+  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;
       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,
@@ -1790,7 +1970,106 @@ var getRewardPool = async (query, marketCoinName) => {
       };
     }
   }
-  return rewardPool;
+  return stakeRewardPool;
+};
+
+// src/queries/borrowIncentiveQuery.ts
+var import_sui_kit2 = require("@scallop-io/sui-kit");
+var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames) => {
+  borrowIncentiveCoinNames = borrowIncentiveCoinNames || [
+    ...SUPPORT_BORROW_INCENTIVE_POOLS
+  ];
+  const queryPkgId = query.address.get("borrowIncentive.query");
+  const incentivePoolsId = query.address.get("borrowIncentive.incentivePools");
+  const txBlock = new import_sui_kit2.SuiTxBlock();
+  const queryTarget = `${queryPkgId}::incentive_pools_query::incentive_pools_data`;
+  txBlock.moveCall(queryTarget, [incentivePoolsId], ["0x2::sui::SUI"]);
+  const queryResult = await query.suiKit.inspectTxn(txBlock);
+  const borrowIncentivePoolsQueryData = queryResult.events[0].parsedJson;
+  const parsedBorrowIncentiveRewardPoolData = parseOriginBorrowIncentiveRewardPoolData(
+    borrowIncentivePoolsQueryData.reward_pool
+  );
+  const rewardCoinType = parsedBorrowIncentiveRewardPoolData.rewardType;
+  const borrowIncentivePools = {};
+  for (const pool of borrowIncentivePoolsQueryData.incentive_pools) {
+    const coinType = "0x" + pool.pool_type.name;
+    const coinName = query.utils.parseCoinNameFromType(coinType);
+    const rewardCoinName = query.utils.parseCoinNameFromType(rewardCoinType);
+    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,
+      symbol: query.utils.parseSymbol(coinName),
+      coinType,
+      rewardCoinType,
+      coinDecimal,
+      rewardCoinDecimal,
+      coinPrice,
+      rewardCoinPrice,
+      maxPoint: parsedBorrowIncentivePoolData.maxPoint,
+      distributedPoint: parsedBorrowIncentivePoolData.distributedPoint,
+      maxStake: parsedBorrowIncentivePoolData.maxStake,
+      ...calculatedBorrowIncentivePoolData,
+      exchangeRateNumerator: parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator,
+      exchangeRateDenominator: parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator,
+      ...calculatedBorrowIncentiveRewardPoolData
+    };
+  }
+  return borrowIncentivePools;
+};
+var queryBorrowIncentiveAccounts = async (query, obligationId, borrowIncentiveCoinNames) => {
+  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 import_sui_kit2.SuiTxBlock();
+  txBlock.moveCall(queryTarget, [incentiveAccountsId, obligationId]);
+  const queryResult = await query.suiKit.inspectTxn(txBlock);
+  const borrowIncentiveAccountsQueryData = queryResult.events[0].parsedJson;
+  const borrowIncentiveAccounts = Object.values(
+    borrowIncentiveAccountsQueryData.incentive_states
+  ).reduce((accounts, accountData) => {
+    const parsedBorrowIncentiveAccount = parseOriginBorrowIncentiveAccountData(accountData);
+    const poolType = parsedBorrowIncentiveAccount.poolType;
+    const coinName = query.utils.parseCoinNameFromType(poolType);
+    if (borrowIncentiveCoinNames && borrowIncentiveCoinNames.includes(coinName)) {
+      accounts[coinName] = {
+        poolType,
+        amount: parsedBorrowIncentiveAccount.amount,
+        points: parsedBorrowIncentiveAccount.points,
+        totalPoints: parsedBorrowIncentiveAccount.totalPoints,
+        index: parsedBorrowIncentiveAccount.index
+      };
+    }
+    return accounts;
+  }, {});
+  return borrowIncentiveAccounts;
 };
 
 // src/queries/priceQuery.ts
@@ -2206,7 +2485,7 @@ var getTotalValueLocked = async (query) => {
 var ScallopQuery = class {
   constructor(params, instance) {
     this.params = params;
-    this.suiKit = instance?.suiKit ?? new import_sui_kit2.SuiKit(params);
+    this.suiKit = instance?.suiKit ?? new import_sui_kit3.SuiKit(params);
     this.address = instance?.address ?? new ScallopAddress({
       id: params?.addressesId || ADDRESSES_ID,
       network: params?.networkType
@@ -2422,38 +2701,60 @@ var ScallopQuery = class {
     return await getStakePool(this, stakeMarketCoinName);
   }
   /**
-   * 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.
    */
-  async getRewardPools(stakeMarketCoinNames) {
+  async getStakeRewardPools(stakeMarketCoinNames) {
     stakeMarketCoinNames = stakeMarketCoinNames ?? [...SUPPORT_SPOOLS];
-    const rewardPools = {};
+    const stakeRewardPools = {};
     for (const stakeMarketCoinName of stakeMarketCoinNames) {
-      const rewardPool = await getRewardPool(this, stakeMarketCoinName);
-      if (rewardPool) {
-        rewardPools[stakeMarketCoinName] = rewardPool;
+      const stakeRewardPool = await getStakeRewardPool(
+        this,
+        stakeMarketCoinName
+      );
+      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.
+   */
+  async getStakeRewardPool(stakeMarketCoinName) {
+    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.
    */
-  async getRewardPool(stakeMarketCoinName) {
-    return await getRewardPool(this, stakeMarketCoinName);
+  async getBorrowIncentivePools(coinNames) {
+    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.
+   */
+  async getBorrowIncentiveAccounts(obligationId, coinNames) {
+    return await queryBorrowIncentiveAccounts(this, obligationId, coinNames);
   }
   /**
    * Get user lending and spool infomation for specific pools.
@@ -2517,16 +2818,25 @@ var ScallopUtils = class {
   constructor(params, instance) {
     this._priceMap = /* @__PURE__ */ new Map();
     /**
-     * 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.
+     */
+    this.getSpoolRewardCoinName = (stakeMarketCoinName) => {
+      return spoolRewardCoins[stakeMarketCoinName];
+    };
+    /**
+     * Get reward type of borrow incentive pool.
+     *
+     * @param borrowIncentiveCoinName - Support borrow incentive coin.
+     * @return Borrow incentive reward coin name.
      */
-    this.getRewardCoinName = (stakeMarketCoinName) => {
-      return rewardCoins[stakeMarketCoinName];
+    this.getBorrowIncentiveRewardCoinName = (borrowIncentiveCoinName) => {
+      return borrowIncentiveRewardCoins[borrowIncentiveCoinName];
     };
     this.params = params;
-    this._suiKit = instance?.suiKit ?? new import_sui_kit3.SuiKit(params);
+    this._suiKit = instance?.suiKit ?? new import_sui_kit4.SuiKit(params);
     this._address = instance?.address ?? new ScallopAddress({
       id: params?.addressesId || ADDRESSES_ID,
       network: params?.networkType
@@ -2580,7 +2890,7 @@ var ScallopUtils = class {
       throw Error(`Coin ${coinName} is not supported`);
     }
     if (coinName === "sui")
-      return (0, import_utils5.normalizeStructTag)(`${coinPackageId}::sui::SUI`);
+      return (0, import_utils7.normalizeStructTag)(`${coinPackageId}::sui::SUI`);
     const wormHolePckageIds = [
       this._address.get("core.coins.usdc.id") ?? wormholeCoinIds.usdc,
       this._address.get("core.coins.usdt.id") ?? wormholeCoinIds.usdt,
@@ -2612,7 +2922,7 @@ var ScallopUtils = class {
     return `${PROTOCOL_OBJECT_ID}::reserve::MarketCoin<${coinType}>`;
   }
   parseCoinNameFromType(coinType) {
-    coinType = (0, import_utils5.normalizeStructTag)(coinType);
+    coinType = (0, import_utils7.normalizeStructTag)(coinType);
     const coinTypeRegex = new RegExp(`((0x[^:]+::[^:]+::[^<>]+))(?![^<>]*<)`);
     const coinTypeMatch = coinType.match(coinTypeRegex);
     const isMarketCoinType = coinType.includes("reserve::MarketCoin");
@@ -2676,7 +2986,7 @@ var ScallopUtils = class {
    * @param coinType - The coin type, default is 0x2::SUI::SUI.
    * @return The selected transaction coin arguments.
    */
-  async selectCoinIds(amount, coinType = import_utils5.SUI_TYPE_ARG, ownerAddress) {
+  async selectCoinIds(amount, coinType = import_utils7.SUI_TYPE_ARG, ownerAddress) {
     ownerAddress = ownerAddress || this._suiKit.currentAddress();
     const coins = await this._suiKit.suiInteractor.selectCoins(
       ownerAddress,
@@ -2796,16 +3106,16 @@ var ScallopUtils = class {
 };
 
 // src/models/scallopBuilder.ts
-var import_utils10 = require("@mysten/sui.js/utils");
-var import_sui_kit6 = require("@scallop-io/sui-kit");
+var import_utils16 = require("@mysten/sui.js/utils");
+var import_sui_kit8 = require("@scallop-io/sui-kit");
 
 // src/builders/coreBuilder.ts
 var import_transactions = require("@mysten/sui.js/transactions");
-var import_utils8 = require("@mysten/sui.js/utils");
-var import_sui_kit4 = require("@scallop-io/sui-kit");
+var import_utils10 = require("@mysten/sui.js/utils");
+var import_sui_kit5 = require("@scallop-io/sui-kit");
 
 // src/builders/oracle.ts
-var import_utils7 = require("@mysten/sui.js/utils");
+var import_utils9 = require("@mysten/sui.js/utils");
 var import_pyth_sui_js2 = require("@pythnetwork/pyth-sui-js");
 var updateOracles = async (builder, txBlock, assetCoinNames) => {
   assetCoinNames = assetCoinNames ?? [
@@ -2911,39 +3221,32 @@ var priceUpdateRequest = (txBlock, packageId, xOracleId, coinType) => {
 var confirmPriceUpdateRequest = (txBlock, packageId, xOracleId, request, coinType) => {
   const target = `${packageId}::x_oracle::confirm_price_update_request`;
   const typeArgs = [coinType];
-  txBlock.moveCall(target, [xOracleId, request, import_utils7.SUI_CLOCK_OBJECT_ID], typeArgs);
+  txBlock.moveCall(target, [xOracleId, request, import_utils9.SUI_CLOCK_OBJECT_ID], typeArgs);
   return txBlock;
 };
 var updateSupraPrice = (txBlock, packageId, request, holderId, registryId, coinType) => {
   txBlock.moveCall(
     `${packageId}::rule::set_price`,
-    [request, holderId, registryId, import_utils7.SUI_CLOCK_OBJECT_ID],
+    [request, holderId, registryId, import_utils9.SUI_CLOCK_OBJECT_ID],
     [coinType]
   );
 };
 var updateSwitchboardPrice = (txBlock, packageId, request, aggregatorId, registryId, coinType) => {
   txBlock.moveCall(
     `${packageId}::rule::set_price`,
-    [request, aggregatorId, registryId, import_utils7.SUI_CLOCK_OBJECT_ID],
+    [request, aggregatorId, registryId, import_utils9.SUI_CLOCK_OBJECT_ID],
     [coinType]
   );
 };
 var updatePythPrice = (txBlock, packageId, request, stateId, feedObjectId, registryId, coinType) => {
   txBlock.moveCall(
     `${packageId}::rule::set_price`,
-    [request, stateId, feedObjectId, registryId, import_utils7.SUI_CLOCK_OBJECT_ID],
+    [request, stateId, feedObjectId, registryId, import_utils9.SUI_CLOCK_OBJECT_ID],
     [coinType]
   );
 };
 
 // src/builders/coreBuilder.ts
-var requireSender = (txBlock) => {
-  const sender = txBlock.blockData.sender;
-  if (!sender) {
-    throw new Error("Sender is required");
-  }
-  return sender;
-};
 var requireObligationInfo = async (...params) => {
   const [builder, txBlock, obligationId, obligationKey] = params;
   if (params.length === 3 && obligationId)
@@ -3004,7 +3307,7 @@ var generateCoreNormalMethod = ({
           coreIds.coinDecimalsRegistry,
           amount,
           coreIds.xOracle,
-          import_utils8.SUI_CLOCK_OBJECT_ID
+          import_utils10.SUI_CLOCK_OBJECT_ID
         ],
         [coinType]
       );
@@ -3013,7 +3316,7 @@ var generateCoreNormalMethod = ({
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return txBlock.moveCall(
         `${coreIds.protocolPkg}::mint::mint`,
-        [coreIds.version, coreIds.market, coin, import_utils8.SUI_CLOCK_OBJECT_ID],
+        [coreIds.version, coreIds.market, coin, import_utils10.SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
@@ -3021,7 +3324,7 @@ var generateCoreNormalMethod = ({
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return txBlock.moveCall(
         `${coreIds.protocolPkg}::mint::mint_entry`,
-        [coreIds.version, coreIds.market, coin, import_utils8.SUI_CLOCK_OBJECT_ID],
+        [coreIds.version, coreIds.market, coin, import_utils10.SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
@@ -3029,7 +3332,7 @@ var generateCoreNormalMethod = ({
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return txBlock.moveCall(
         `${coreIds.protocolPkg}::redeem::redeem`,
-        [coreIds.version, coreIds.market, marketCoin, import_utils8.SUI_CLOCK_OBJECT_ID],
+        [coreIds.version, coreIds.market, marketCoin, import_utils10.SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
@@ -3037,7 +3340,7 @@ var generateCoreNormalMethod = ({
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return txBlock.moveCall(
         `${coreIds.protocolPkg}::redeem::redeem_entry`,
-        [coreIds.version, coreIds.market, marketCoin, import_utils8.SUI_CLOCK_OBJECT_ID],
+        [coreIds.version, coreIds.market, marketCoin, import_utils10.SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
@@ -3053,7 +3356,7 @@ var generateCoreNormalMethod = ({
           coreIds.coinDecimalsRegistry,
           amount,
           coreIds.xOracle,
-          import_utils8.SUI_CLOCK_OBJECT_ID
+          import_utils10.SUI_CLOCK_OBJECT_ID
         ],
         [coinType]
       );
@@ -3070,7 +3373,7 @@ var generateCoreNormalMethod = ({
           coreIds.coinDecimalsRegistry,
           amount,
           coreIds.xOracle,
-          import_utils8.SUI_CLOCK_OBJECT_ID
+          import_utils10.SUI_CLOCK_OBJECT_ID
         ],
         [coinType]
       );
@@ -3084,7 +3387,7 @@ var generateCoreNormalMethod = ({
           obligation,
           coreIds.market,
           coin,
-          import_utils8.SUI_CLOCK_OBJECT_ID
+          import_utils10.SUI_CLOCK_OBJECT_ID
         ],
         [coinType]
       );
@@ -3233,7 +3536,7 @@ var generateCoreQuickMethod = ({
   };
 };
 var newCoreTxBlock = (builder, initTxBlock) => {
-  const txBlock = initTxBlock instanceof import_transactions.TransactionBlock ? new import_sui_kit4.SuiTxBlock(initTxBlock) : initTxBlock ? initTxBlock : new import_sui_kit4.SuiTxBlock();
+  const txBlock = initTxBlock instanceof import_transactions.TransactionBlock ? new import_sui_kit5.SuiTxBlock(initTxBlock) : initTxBlock ? initTxBlock : new import_sui_kit5.SuiTxBlock();
   const normalMethod = generateCoreNormalMethod({
     builder,
     txBlock
@@ -3262,20 +3565,13 @@ var newCoreTxBlock = (builder, initTxBlock) => {
 
 // src/builders/spoolBuilder.ts
 var import_transactions2 = require("@mysten/sui.js/transactions");
-var import_utils9 = require("@mysten/sui.js/utils");
-var import_sui_kit5 = require("@scallop-io/sui-kit");
-var requireSender2 = (txBlock) => {
-  const sender = txBlock.blockData.sender;
-  if (!sender) {
-    throw new Error("Sender is required");
-  }
-  return sender;
-};
+var import_utils12 = require("@mysten/sui.js/utils");
+var import_sui_kit6 = require("@scallop-io/sui-kit");
 var requireStakeAccountIds = async (...params) => {
   const [builder, txBlock, stakeMarketCoinName, stakeAccountId] = params;
   if (params.length === 4 && stakeAccountId)
     return [stakeAccountId];
-  const sender = requireSender2(txBlock);
+  const sender = requireSender(txBlock);
   const stakeAccounts = await getStakeAccounts(builder.query, sender);
   if (stakeAccounts[stakeMarketCoinName].length === 0) {
     throw new Error(`No stake account id found for sender ${sender}`);
@@ -3284,7 +3580,7 @@ var requireStakeAccountIds = async (...params) => {
 };
 var requireStakeAccounts = async (...params) => {
   const [builder, txBlock, stakeMarketCoinName, stakeAccountId] = params;
-  const sender = requireSender2(txBlock);
+  const sender = requireSender(txBlock);
   const stakeAccounts = await getStakeAccounts(builder.query, sender);
   if (stakeAccounts[stakeMarketCoinName].length === 0) {
     throw new Error(`No stake account found for sender ${sender}`);
@@ -3309,7 +3605,7 @@ var generateSpoolNormalMethod = ({
       );
       return txBlock.moveCall(
         `${spoolIds.spoolPkg}::user::new_spool_account`,
-        [stakePoolId, import_utils9.SUI_CLOCK_OBJECT_ID],
+        [stakePoolId, import_utils12.SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
@@ -3320,7 +3616,7 @@ var generateSpoolNormalMethod = ({
       );
       txBlock.moveCall(
         `${spoolIds.spoolPkg}::user::stake`,
-        [stakePoolId, stakeAccount, coin, import_utils9.SUI_CLOCK_OBJECT_ID],
+        [stakePoolId, stakeAccount, coin, import_utils12.SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
@@ -3331,7 +3627,7 @@ var generateSpoolNormalMethod = ({
       );
       return txBlock.moveCall(
         `${spoolIds.spoolPkg}::user::unstake`,
-        [stakePoolId, stakeAccount, amount, import_utils9.SUI_CLOCK_OBJECT_ID],
+        [stakePoolId, stakeAccount, amount, import_utils12.SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
@@ -3343,11 +3639,11 @@ var generateSpoolNormalMethod = ({
         `spool.pools.${stakeMarketCoinName}.rewardPoolId`
       );
       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`,
-        [stakePoolId, rewardPoolId, stakeAccount, import_utils9.SUI_CLOCK_OBJECT_ID],
+        [stakePoolId, rewardPoolId, stakeAccount, import_utils12.SUI_CLOCK_OBJECT_ID],
         [marketCoinType, rewardCoinType]
       );
     }
@@ -3359,7 +3655,7 @@ var generateSpoolQuickMethod = ({
 }) => {
   return {
     stakeQuick: async (amountOrMarketCoin, stakeMarketCoinName, stakeAccountId) => {
-      const sender = requireSender2(txBlock);
+      const sender = requireSender(txBlock);
       const stakeAccountIds = await requireStakeAccountIds(
         builder,
         txBlock,
@@ -3418,17 +3714,17 @@ var generateSpoolQuickMethod = ({
         stakeMarketCoinName,
         stakeAccountId
       );
-      const rewardCoins2 = [];
+      const rewardCoins = [];
       for (const accountId of stakeAccountIds) {
         const rewardCoin = txBlock.claim(accountId, stakeMarketCoinName);
-        rewardCoins2.push(rewardCoin);
+        rewardCoins.push(rewardCoin);
       }
-      return rewardCoins2;
+      return rewardCoins;
     }
   };
 };
 var newSpoolTxBlock = (builder, initTxBlock) => {
-  const txBlock = initTxBlock instanceof import_transactions2.TransactionBlock ? new import_sui_kit5.SuiTxBlock(initTxBlock) : initTxBlock ? initTxBlock : new import_sui_kit5.SuiTxBlock();
+  const txBlock = initTxBlock instanceof import_transactions2.TransactionBlock ? new import_sui_kit6.SuiTxBlock(initTxBlock) : initTxBlock ? initTxBlock : new import_sui_kit6.SuiTxBlock();
   const normalMethod = generateSpoolNormalMethod({
     builder,
     txBlock
@@ -3455,13 +3751,183 @@ var newSpoolTxBlock = (builder, initTxBlock) => {
   });
 };
 
+// src/builders/borrowIncentiveBuilder.ts
+var import_transactions3 = require("@mysten/sui.js/transactions");
+var import_utils14 = require("@mysten/sui.js/utils");
+var import_sui_kit7 = require("@scallop-io/sui-kit");
+var requireObligationInfo2 = async (...params) => {
+  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
+  };
+};
+var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
+  const 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,
+          import_utils14.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,
+          import_utils14.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,
+          import_utils14.SUI_CLOCK_OBJECT_ID
+        ],
+        [rewardType]
+      );
+    }
+  };
+};
+var generateBorrowIncentiveQuickMethod = ({ builder, txBlock }) => {
+  return {
+    stakeObligationQuick: async (coinName, obligation, obligationKey) => {
+      const {
+        obligationId: obligationArg,
+        obligationKey: obligationtKeyArg,
+        obligationLocked
+      } = await requireObligationInfo2(
+        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
+      } = await requireObligationInfo2(
+        builder,
+        txBlock,
+        obligation,
+        obligationKey
+      );
+      if (obligationLocked) {
+        txBlock.unstakeObligation(obligationArg, obligationtKeyArg, coinName);
+      }
+    },
+    claimBorrowIncentiveQuick: async (coinName, obligation, obligationKey) => {
+      const {
+        obligationId: obligationArg,
+        obligationKey: obligationtKeyArg
+      } = await requireObligationInfo2(
+        builder,
+        txBlock,
+        obligation,
+        obligationKey
+      );
+      return txBlock.claimBorrowIncentive(
+        obligationArg,
+        obligationtKeyArg,
+        coinName
+      );
+    }
+  };
+};
+var newBorrowIncentiveTxBlock = (builder, initTxBlock) => {
+  const txBlock = initTxBlock instanceof import_transactions3.TransactionBlock ? new import_sui_kit7.SuiTxBlock(initTxBlock) : initTxBlock ? initTxBlock : new import_sui_kit7.SuiTxBlock();
+  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);
+    }
+  });
+  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);
+    }
+  });
+};
+
 // src/builders/index.ts
 var newScallopTxBlock = (builder, initTxBlock) => {
-  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);
@@ -3473,7 +3939,7 @@ var newScallopTxBlock = (builder, initTxBlock) => {
 var ScallopBuilder = class {
   constructor(params, instance) {
     this.params = params;
-    this.suiKit = instance?.suiKit ?? new import_sui_kit6.SuiKit(params);
+    this.suiKit = instance?.suiKit ?? new import_sui_kit8.SuiKit(params);
     this.address = instance?.address ?? new ScallopAddress({
       id: params?.addressesId || ADDRESSES_ID,
       network: params?.networkType
@@ -3487,7 +3953,7 @@ var ScallopBuilder = class {
       address: this.address,
       query: this.query
     });
-    this.walletAddress = (0, import_utils10.normalizeSuiAddress)(
+    this.walletAddress = (0, import_utils16.normalizeSuiAddress)(
       params?.walletAddress || this.suiKit.currentAddress()
     );
     this.isTestnet = params.networkType ? params.networkType === "testnet" : false;
@@ -3563,7 +4029,7 @@ var ScallopBuilder = class {
 var ScallopClient = class {
   constructor(params, instance) {
     this.params = params;
-    this.suiKit = instance?.suiKit ?? new import_sui_kit7.SuiKit(params);
+    this.suiKit = instance?.suiKit ?? new import_sui_kit9.SuiKit(params);
     this.address = instance?.address ?? new ScallopAddress({
       id: params?.addressesId || ADDRESSES_ID,
       network: params?.networkType
@@ -3583,7 +4049,7 @@ var ScallopClient = class {
       query: this.query,
       utils: this.utils
     });
-    this.walletAddress = (0, import_utils11.normalizeSuiAddress)(
+    this.walletAddress = (0, import_utils17.normalizeSuiAddress)(
       params?.walletAddress || this.suiKit.currentAddress()
     );
   }
@@ -3685,8 +4151,8 @@ var ScallopClient = class {
    * @param stakeMarketCoinName - Support stake market coin.
    * @return Reward pool data.
    */
-  async getRewardPool(stakeMarketCoinName) {
-    return await this.query.getRewardPool(stakeMarketCoinName);
+  async getStakeRewardPool(stakeMarketCoinName) {
+    return await this.query.getStakeRewardPool(stakeMarketCoinName);
   }
   async openObligation(sign = true) {
     const txBlock = this.builder.createTxBlock();
@@ -3958,11 +4424,84 @@ var ScallopClient = class {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
-    const rewardCoins2 = await txBlock.claimQuick(
+    const rewardCoins = await txBlock.claimQuick(
       stakeMarketCoinName,
       stakeAccountId
     );
-    txBlock.transferObjects(rewardCoins2, sender);
+    txBlock.transferObjects(rewardCoins, sender);
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  /* ==================== 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
+   */
+  async stakeObligation(coinName, obligaionId, obligaionKeyId, sign = true, walletAddress) {
+    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
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  /**
+   * 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
+   */
+  async unstakeObligation(coinName, obligaionId, obligaionKeyId, sign = true, walletAddress) {
+    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
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  /**
+   * 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
+   */
+  async claimBorrowIncentive(coinName, obligaionId, obligaionKeyId, sign = true, walletAddress) {
+    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
@@ -3997,7 +4536,7 @@ var ScallopClient = class {
 var Scallop = class {
   constructor(params) {
     this.params = params;
-    this.suiKit = new import_sui_kit8.SuiKit(params);
+    this.suiKit = new import_sui_kit10.SuiKit(params);
     this._address = new ScallopAddress({
       id: params?.addressesId || ADDRESSES_ID,
       network: params?.networkType
@@ -4076,12 +4615,14 @@ var Scallop = class {
   ADDRESSES_ID,
   API_BASE_URL,
   PROTOCOL_OBJECT_ID,
+  SUPPORT_BORROW_INCENTIVE_POOLS,
+  SUPPORT_BORROW_INCENTIVE_REWARDS,
   SUPPORT_COLLATERALS,
   SUPPORT_ORACLES,
   SUPPORT_PACKAGES,
   SUPPORT_POOLS,
-  SUPPORT_REWARD_POOLS,
   SUPPORT_SPOOLS,
+  SUPPORT_SPOOLS_REWARDS,
   Scallop,
   ScallopAddress,
   ScallopBuilder,
@@ -4089,10 +4630,11 @@ var Scallop = class {
   ScallopQuery,
   ScallopUtils,
   assetCoins,
+  borrowIncentiveRewardCoins,
   coinDecimals,
   coinIds,
   marketCoins,
-  rewardCoins,
+  spoolRewardCoins,
   stakeMarketCoins,
   voloCoinIds,
   wormholeCoinIds