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

package/dist/index.mjs

@@ -29,7 +29,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",
@@ -102,11 +104,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",
@@ -144,6 +150,7 @@ var EMPTY_ADDRESSES = {
     market: "",
     adminCap: "",
     coinDecimalsRegistry: "",
+    obligationAccessStore: "",
     coins: {
       btc: {
         id: "",
@@ -327,6 +334,13 @@ var EMPTY_ADDRESSES = {
         rewardPoolId: ""
       }
     }
+  },
+  borrowIncentive: {
+    id: "",
+    adminCap: "",
+    query: "",
+    incentivePools: "",
+    incentiveAccounts: ""
   }
 };
 var ScallopAddress = class {
@@ -634,7 +648,7 @@ import { normalizeSuiAddress as normalizeSuiAddress2 } from "@mysten/sui.js/util
 import { SuiKit as SuiKit4 } from "@scallop-io/sui-kit";
 
 // src/models/scallopUtils.ts
-import { SUI_TYPE_ARG, normalizeStructTag as normalizeStructTag2 } from "@mysten/sui.js/utils";
+import { SUI_TYPE_ARG, normalizeStructTag as normalizeStructTag5 } from "@mysten/sui.js/utils";
 import { SuiKit as SuiKit2 } from "@scallop-io/sui-kit";
 import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 
@@ -642,34 +656,25 @@ import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 import { SuiKit } from "@scallop-io/sui-kit";
 
 // src/queries/coreQuery.ts
+import { normalizeStructTag as normalizeStructTag2 } from "@mysten/sui.js/utils";
 import { SuiTxBlock as SuiKitTxBlock } from "@scallop-io/sui-kit";
 import BigNumber2 from "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
 import BigNumber from "bignumber.js";
+import { normalizeStructTag } from "@mysten/sui.js/utils";
 var parseOriginMarketPoolData = (originMarketPoolData) => {
   return {
-    coinType: "0x" + originMarketPoolData.type.name,
+    coinType: normalizeStructTag(originMarketPoolData.type.name),
     // Parse origin data required for basic calculations.
     maxBorrowRate: Number(originMarketPoolData.maxBorrowRate.value) / 2 ** 32,
     borrowRate: Number(originMarketPoolData.interestRate.value) / 2 ** 32,
@@ -763,7 +768,7 @@ var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
 };
 var parseOriginMarketCollateralData = (originMarketCollateralData) => {
   return {
-    coinType: "0x" + originMarketCollateralData.type.name,
+    coinType: normalizeStructTag(originMarketCollateralData.type.name),
     collateralFactor: Number(originMarketCollateralData.collateralFactor.value) / 2 ** 32,
     liquidationFactor: Number(originMarketCollateralData.liquidationFactor.value) / 2 ** 32,
     liquidationDiscount: Number(originMarketCollateralData.liquidationDiscount.value) / 2 ** 32,
@@ -793,48 +798,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: normalizeStructTag(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 = BigNumber(
-    parsedStakePoolData.pointPerPeriod
-  ).dividedBy(parsedStakePoolData.period);
-  const pointPerSec = BigNumber(parsedStakePoolData.pointPerPeriod).dividedBy(
-    parsedStakePoolData.period
+    parsedSpoolData.pointPerPeriod
+  ).dividedBy(parsedSpoolData.period);
+  const pointPerSec = BigNumber(parsedSpoolData.pointPerPeriod).dividedBy(
+    parsedSpoolData.period
   );
-  const remainingPeriod = BigNumber(parsedStakePoolData.maxPoint).minus(parsedStakePoolData.distributedPoint).dividedBy(pointPerSec);
-  const startDate = parsedStakePoolData.createdAt;
-  const endDate = remainingPeriod.plus(parsedStakePoolData.lastUpdate).integerValue().toNumber();
+  const remainingPeriod = BigNumber(parsedSpoolData.maxPoint).minus(parsedSpoolData.distributedPoint).dividedBy(pointPerSec);
+  const startDate = parsedSpoolData.createdAt;
+  const endDate = remainingPeriod.plus(parsedSpoolData.lastUpdate).integerValue().toNumber();
   const timeDelta = BigNumber(
-    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedStakePoolData.lastUpdate
-  ).dividedBy(parsedStakePoolData.period).toFixed(0);
-  const remainingPoints = BigNumber(parsedStakePoolData.maxPoint).minus(
-    parsedStakePoolData.distributedPoint
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedSpoolData.lastUpdate
+  ).dividedBy(parsedSpoolData.period).toFixed(0);
+  const remainingPoints = BigNumber(parsedSpoolData.maxPoint).minus(
+    parsedSpoolData.distributedPoint
   );
   const accumulatedPoints = BigNumber.minimum(
-    BigNumber(timeDelta).multipliedBy(parsedStakePoolData.pointPerPeriod),
+    BigNumber(timeDelta).multipliedBy(parsedSpoolData.pointPerPeriod),
     remainingPoints
   );
-  const currentPointIndex = BigNumber(parsedStakePoolData.index).plus(
-    accumulatedPoints.dividedBy(parsedStakePoolData.staked).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedStakePoolData.staked) : 0
+  const currentPointIndex = BigNumber(parsedSpoolData.index).plus(
+    accumulatedPoints.dividedBy(parsedSpoolData.staked).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedSpoolData.staked) : 0
   );
   const currentTotalDistributedPoint = BigNumber(
-    parsedStakePoolData.distributedPoint
+    parsedSpoolData.distributedPoint
   ).plus(accumulatedPoints);
-  const stakedAmount = BigNumber(parsedStakePoolData.staked);
+  const stakedAmount = BigNumber(parsedSpoolData.staked);
   const stakedCoin = stakedAmount.shiftedBy(-1 * stakeMarketCoinDecimal);
   const stakedValue = stakedCoin.multipliedBy(stakeMarketCoinPrice);
   return {
@@ -849,35 +854,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 = BigNumber(calculatedStakePoolData.distributedPointPerSec).multipliedBy(parsedRewardPoolData.exchangeRateNumerator).dividedBy(parsedRewardPoolData.exchangeRateDenominator);
-  const totalRewardAmount = BigNumber(parsedStakePoolData.maxPoint).multipliedBy(parsedRewardPoolData.exchangeRateNumerator).dividedBy(parsedRewardPoolData.exchangeRateDenominator);
+  const rewardPerSec = BigNumber(calculatedSpoolData.distributedPointPerSec).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
+  const totalRewardAmount = BigNumber(parsedSpoolData.maxPoint).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
   const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
   const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
-  const remaindRewardAmount = BigNumber(parsedRewardPoolData.rewards);
+  const remaindRewardAmount = BigNumber(parsedSpoolRewardPoolData.rewards);
   const remaindRewardCoin = remaindRewardAmount.shiftedBy(
     -1 * rewardCoinDecimal
   );
   const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
-  const claimedRewardAmount = BigNumber(parsedRewardPoolData.claimedRewards);
+  const claimedRewardAmount = BigNumber(
+    parsedSpoolRewardPoolData.claimedRewards
+  );
   const claimedRewardCoin = claimedRewardAmount.shiftedBy(
     -1 * rewardCoinDecimal
   );
   const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
   const rewardValueForYear = BigNumber(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(),
@@ -889,9 +898,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: 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 = BigNumber(
+    parsedBorrowIncentivePoolData.pointPerPeriod
+  ).dividedBy(parsedBorrowIncentivePoolData.period);
+  const pointPerSec = BigNumber(
+    parsedBorrowIncentivePoolData.pointPerPeriod
+  ).dividedBy(parsedBorrowIncentivePoolData.period);
+  const remainingPeriod = BigNumber(parsedBorrowIncentivePoolData.maxPoint).minus(parsedBorrowIncentivePoolData.distributedPoint).dividedBy(pointPerSec);
+  const startDate = parsedBorrowIncentivePoolData.createdAt;
+  const endDate = remainingPeriod.plus(parsedBorrowIncentivePoolData.lastUpdate).integerValue().toNumber();
+  const timeDelta = BigNumber(
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedBorrowIncentivePoolData.lastUpdate
+  ).dividedBy(parsedBorrowIncentivePoolData.period).toFixed(0);
+  const remainingPoints = BigNumber(
+    parsedBorrowIncentivePoolData.maxPoint
+  ).minus(parsedBorrowIncentivePoolData.distributedPoint);
+  const accumulatedPoints = BigNumber.minimum(
+    BigNumber(timeDelta).multipliedBy(
+      parsedBorrowIncentivePoolData.pointPerPeriod
+    ),
+    remainingPoints
+  );
+  const currentPointIndex = BigNumber(parsedBorrowIncentivePoolData.index).plus(
+    accumulatedPoints.dividedBy(parsedBorrowIncentivePoolData.staked).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedBorrowIncentivePoolData.staked) : 0
+  );
+  const currentTotalDistributedPoint = BigNumber(
+    parsedBorrowIncentivePoolData.distributedPoint
+  ).plus(accumulatedPoints);
+  const stakedAmount = BigNumber(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: 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 = BigNumber(
+    calculatedBorrowIncentivePoolData.distributedPointPerSec
+  ).multipliedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator).dividedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator);
+  const totalRewardAmount = BigNumber(parsedBorrowIncentivePoolData.maxPoint).multipliedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator).dividedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator);
+  const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
+  const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
+  const remaindRewardAmount = BigNumber(
+    parsedBorrowIncentiveRewardPoolData.remainingRewards
+  );
+  const remaindRewardCoin = remaindRewardAmount.shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
+  const claimedRewardAmount = BigNumber(
+    parsedBorrowIncentiveRewardPoolData.claimedRewards
+  );
+  const claimedRewardCoin = claimedRewardAmount.shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
+  const rewardValueForYear = BigNumber(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: 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) => {
@@ -909,7 +1042,7 @@ var isMarketCoin = (coinName) => {
     .../* @__PURE__ */ new Set([
       ...SUPPORT_POOLS,
       ...SUPPORT_COLLATERALS,
-      ...SUPPORT_REWARD_POOLS
+      ...SUPPORT_SPOOLS_REWARDS
     ])
   ].includes(assetCoinName);
 };
@@ -925,6 +1058,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) => {
@@ -938,6 +1089,12 @@ var queryMarket = async (query) => {
   const pools = {};
   const collaterals = {};
   for (const pool of marketData.pools) {
+    const coinType = normalizeStructTag2(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,
@@ -962,9 +1119,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),
@@ -983,6 +1137,12 @@ var queryMarket = async (query) => {
     };
   }
   for (const collateral of marketData.collaterals) {
+    const coinType = normalizeStructTag2(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,
@@ -997,9 +1157,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),
@@ -1286,11 +1443,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`;
@@ -1465,7 +1638,7 @@ var getMarketCoinAmount = async (query, marketCoinName, ownerAddress) => {
 };
 
 // src/queries/spoolQuery.ts
-import { normalizeStructTag } from "@mysten/sui.js/utils";
+import { normalizeStructTag as normalizeStructTag3 } from "@mysten/sui.js/utils";
 var getSpools = async (query, stakeMarketCoinNames) => {
   stakeMarketCoinNames = stakeMarketCoinNames || [...SUPPORT_SPOOLS];
   const stakeCoinNames = stakeMarketCoinNames.map(
@@ -1486,31 +1659,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,
@@ -1522,43 +1695,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
         };
       }
@@ -1616,34 +1794,34 @@ var getStakeAccounts = async (query, ownerAddress) => {
       const index = Number(fields.index);
       const points = Number(fields.points);
       const totalPoints = Number(fields.total_points);
-      if (normalizeStructTag(type) === stakeMarketCoinTypes.ssui) {
+      if (normalizeStructTag3(type) === stakeMarketCoinTypes.ssui) {
         stakeAccounts.ssui.push({
           id,
-          type,
+          type: normalizeStructTag3(type),
           stakePoolId,
-          stakeType,
+          stakeType: normalizeStructTag3(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if (normalizeStructTag(type) === stakeMarketCoinTypes.susdc) {
+      } else if (normalizeStructTag3(type) === stakeMarketCoinTypes.susdc) {
         stakeAccounts.susdc.push({
           id,
-          type,
+          type: normalizeStructTag3(type),
           stakePoolId,
-          stakeType,
+          stakeType: normalizeStructTag3(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if (normalizeStructTag(type) === stakeMarketCoinTypes.susdt) {
+      } else if (normalizeStructTag3(type) === stakeMarketCoinTypes.susdt) {
         stakeAccounts.susdt.push({
           id,
-          type,
+          type: normalizeStructTag3(type),
           stakePoolId,
-          stakeType,
+          stakeType: normalizeStructTag3(stakeType),
           staked,
           index,
           points,
@@ -1682,13 +1860,13 @@ var getStakePool = async (query, marketCoinName) => {
       const lastUpdate = Number(fields.last_update);
       stakePool = {
         id,
-        type,
+        type: normalizeStructTag3(type),
         maxPoint,
         distributedPoint,
         pointPerPeriod,
         period,
         maxStake,
-        stakeType,
+        stakeType: normalizeStructTag3(stakeType),
         totalStaked,
         index,
         createdAt,
@@ -1698,32 +1876,32 @@ 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,
+        type: normalizeStructTag3(type),
         stakePoolId,
         ratioNumerator,
         ratioDenominator,
@@ -1732,7 +1910,107 @@ var getRewardPool = async (query, marketCoinName) => {
       };
     }
   }
-  return rewardPool;
+  return stakeRewardPool;
+};
+
+// src/queries/borrowIncentiveQuery.ts
+import { normalizeStructTag as normalizeStructTag4 } from "@mysten/sui.js/utils";
+import { SuiTxBlock as SuiKitTxBlock2 } from "@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 SuiKitTxBlock2();
+  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 = normalizeStructTag4(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 SuiKitTxBlock2();
+  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
@@ -1853,15 +2131,19 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
       availableUnstakeAmount = availableUnstakeAmount.plus(
         accountStakedMarketCoinAmount
       );
-      availableUnstakeCoin = availableUnstakeAmount.shiftedBy(-1 * coinDecimal);
+      availableUnstakeCoin = availableUnstakeAmount.shiftedBy(
+        -1 * spool.coinDecimal
+      );
       const baseIndexRate = 1e9;
       const increasedPointRate = spool?.currentPointIndex ? BigNumber3(spool.currentPointIndex - stakeAccount.index).dividedBy(
         baseIndexRate
       ) : 1;
       availableClaimAmount = availableClaimAmount.plus(
-        BigNumber3(stakeAccount.staked).multipliedBy(increasedPointRate).plus(stakeAccount.points).multipliedBy(spool.exchangeRateNumerator).dividedBy(spool.exchangeRateDenominator)
+        accountStakedMarketCoinAmount.multipliedBy(increasedPointRate).plus(stakeAccount.points).multipliedBy(spool.exchangeRateNumerator).dividedBy(spool.exchangeRateDenominator)
+      );
+      availableClaimCoin = availableClaimAmount.shiftedBy(
+        -1 * spool.rewardCoinDecimal
       );
-      availableClaimCoin = availableClaimAmount.shiftedBy(-1 * coinDecimal);
     }
   }
   const suppliedAmount = BigNumber3(marketCoinAmount).multipliedBy(
@@ -1946,10 +2228,13 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
     ])
   ];
   const obligationQuery = await query.queryObligation(obligationId);
+  const borrowIncentivePools = await query.getBorrowIncentivePools();
+  const borrowIncentiveAccounts = await query.getBorrowIncentiveAccounts(obligationId);
   coinPrices = coinPrices || await query.utils.getCoinPrices(assetCoinNames);
   coinAmounts = coinAmounts || await query.getCoinAmounts(assetCoinNames, ownerAddress);
   const collaterals = {};
   const debts = {};
+  const borrowIncentives = {};
   let totalDepositedPools = 0;
   let totalDepositedValue = BigNumber3(0);
   let totalBorrowCapacityValue = BigNumber3(0);
@@ -2051,6 +2336,41 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       };
     }
   }
+  for (const [poolCoinName, borrowIncentiveAccount] of Object.entries(
+    borrowIncentiveAccounts
+  )) {
+    const coinName = poolCoinName;
+    const borrowIncentivePool = borrowIncentivePools[coinName];
+    let availableClaimAmount = BigNumber3(0);
+    let availableClaimCoin = BigNumber3(0);
+    if (borrowIncentivePool) {
+      const accountBorrowedAmount = BigNumber3(borrowIncentiveAccount.amount);
+      const baseIndexRate = 1e9;
+      const increasedPointRate = borrowIncentivePool.currentPointIndex ? BigNumber3(
+        borrowIncentivePool.currentPointIndex - borrowIncentiveAccount.index
+      ).dividedBy(baseIndexRate) : 1;
+      availableClaimAmount = availableClaimAmount.plus(
+        accountBorrowedAmount.multipliedBy(increasedPointRate).plus(borrowIncentiveAccount.points).multipliedBy(borrowIncentivePool.exchangeRateNumerator).dividedBy(borrowIncentivePool.exchangeRateDenominator)
+      );
+      availableClaimCoin = availableClaimAmount.shiftedBy(
+        -1 * borrowIncentivePool.rewardCoinDecimal
+      );
+      if (availableClaimAmount.isGreaterThan(0)) {
+        borrowIncentives[coinName] = {
+          coinName: borrowIncentivePool.coinName,
+          coinType: borrowIncentivePool.coinType,
+          rewardCoinType: borrowIncentivePool.rewardCoinType,
+          symbol: borrowIncentivePool.symbol,
+          coinDecimal: borrowIncentivePool.coinDecimal,
+          rewardCoinDecimal: borrowIncentivePool.rewardCoinDecimal,
+          coinPrice: borrowIncentivePool.coinPrice,
+          rewardCoinPrice: borrowIncentivePool.rewardCoinPrice,
+          availableClaimAmount: availableClaimAmount.toNumber(),
+          availableClaimCoin: availableClaimCoin.toNumber()
+        };
+      }
+    }
+  }
   let riskLevel = totalRequiredCollateralValue.isZero() && totalBorrowedValueWithWeight.isZero() ? BigNumber3(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
   riskLevel = riskLevel.isFinite() ? riskLevel.isLessThan(1) ? riskLevel : BigNumber3(1) : BigNumber3(1);
   const accountBalanceValue = totalDepositedValue.minus(totalBorrowedValue).isGreaterThan(0) ? totalDepositedValue.minus(totalBorrowedValue) : BigNumber3(0);
@@ -2079,7 +2399,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
     totalDepositedPools,
     totalBorrowedPools,
     collaterals,
-    debts
+    debts,
+    borrowIncentives
   };
   for (const [collateralCoinName, obligationCollateral] of Object.entries(
     obligationAccount.collaterals
@@ -2095,10 +2416,10 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       obligationCollateral.availableWithdrawCoin = availableWithdrawAmount.shiftedBy(-1 * obligationCollateral.coinDecimal).toNumber();
     }
   }
-  for (const [assetCoinName, obligationDebt] of Object.entries(
+  for (const [poolCoinName, obligationDebt] of Object.entries(
     obligationAccount.debts
   )) {
-    const marketPool = market.pools[assetCoinName];
+    const marketPool = market.pools[poolCoinName];
     if (marketPool) {
       const availableRepayAmount = BigNumber3(
         obligationDebt.availableRepayAmount
@@ -2364,38 +2685,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 getRewardPool(stakeMarketCoinName) {
-    return await getRewardPool(this, stakeMarketCoinName);
+  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 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.
@@ -2459,13 +2802,22 @@ 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 SuiKit2(params);
@@ -2522,7 +2874,7 @@ var ScallopUtils = class {
       throw Error(`Coin ${coinName} is not supported`);
     }
     if (coinName === "sui")
-      return normalizeStructTag2(`${coinPackageId}::sui::SUI`);
+      return normalizeStructTag5(`${coinPackageId}::sui::SUI`);
     const wormHolePckageIds = [
       this._address.get("core.coins.usdc.id") ?? wormholeCoinIds.usdc,
       this._address.get("core.coins.usdt.id") ?? wormholeCoinIds.usdt,
@@ -2554,7 +2906,7 @@ var ScallopUtils = class {
     return `${PROTOCOL_OBJECT_ID}::reserve::MarketCoin<${coinType}>`;
   }
   parseCoinNameFromType(coinType) {
-    coinType = normalizeStructTag2(coinType);
+    coinType = normalizeStructTag5(coinType);
     const coinTypeRegex = new RegExp(`((0x[^:]+::[^:]+::[^<>]+))(?![^<>]*<)`);
     const coinTypeMatch = coinType.match(coinTypeRegex);
     const isMarketCoinType = coinType.includes("reserve::MarketCoin");
@@ -2744,7 +3096,7 @@ import { SuiKit as SuiKit3 } from "@scallop-io/sui-kit";
 // src/builders/coreBuilder.ts
 import { TransactionBlock } from "@mysten/sui.js/transactions";
 import { SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID2 } from "@mysten/sui.js/utils";
-import { SuiTxBlock as SuiKitTxBlock2 } from "@scallop-io/sui-kit";
+import { SuiTxBlock as SuiKitTxBlock3 } from "@scallop-io/sui-kit";
 
 // src/builders/oracle.ts
 import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui.js/utils";
@@ -2882,13 +3234,6 @@ var updatePythPrice = (txBlock, packageId, request, stateId, feedObjectId, regis
 };
 
 // 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)
@@ -3178,7 +3523,7 @@ var generateCoreQuickMethod = ({
   };
 };
 var newCoreTxBlock = (builder, initTxBlock) => {
-  const txBlock = initTxBlock instanceof TransactionBlock ? new SuiKitTxBlock2(initTxBlock) : initTxBlock ? initTxBlock : new SuiKitTxBlock2();
+  const txBlock = initTxBlock instanceof TransactionBlock ? new SuiKitTxBlock3(initTxBlock) : initTxBlock ? initTxBlock : new SuiKitTxBlock3();
   const normalMethod = generateCoreNormalMethod({
     builder,
     txBlock
@@ -3208,19 +3553,12 @@ var newCoreTxBlock = (builder, initTxBlock) => {
 // src/builders/spoolBuilder.ts
 import { TransactionBlock as TransactionBlock2 } from "@mysten/sui.js/transactions";
 import { SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID3 } from "@mysten/sui.js/utils";
-import { SuiTxBlock as SuiKitTxBlock3 } from "@scallop-io/sui-kit";
-var requireSender2 = (txBlock) => {
-  const sender = txBlock.blockData.sender;
-  if (!sender) {
-    throw new Error("Sender is required");
-  }
-  return sender;
-};
+import { SuiTxBlock as SuiKitTxBlock4 } from "@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}`);
@@ -3229,7 +3567,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}`);
@@ -3288,7 +3626,7 @@ 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`,
@@ -3304,7 +3642,7 @@ var generateSpoolQuickMethod = ({
 }) => {
   return {
     stakeQuick: async (amountOrMarketCoin, stakeMarketCoinName, stakeAccountId) => {
-      const sender = requireSender2(txBlock);
+      const sender = requireSender(txBlock);
       const stakeAccountIds = await requireStakeAccountIds(
         builder,
         txBlock,
@@ -3363,17 +3701,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 TransactionBlock2 ? new SuiKitTxBlock3(initTxBlock) : initTxBlock ? initTxBlock : new SuiKitTxBlock3();
+  const txBlock = initTxBlock instanceof TransactionBlock2 ? new SuiKitTxBlock4(initTxBlock) : initTxBlock ? initTxBlock : new SuiKitTxBlock4();
   const normalMethod = generateSpoolNormalMethod({
     builder,
     txBlock
@@ -3400,13 +3738,183 @@ var newSpoolTxBlock = (builder, initTxBlock) => {
   });
 };
 
+// src/builders/borrowIncentiveBuilder.ts
+import { TransactionBlock as TransactionBlock3 } from "@mysten/sui.js/transactions";
+import { SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID4 } from "@mysten/sui.js/utils";
+import { SuiTxBlock as SuiKitTxBlock5 } from "@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,
+          SUI_CLOCK_OBJECT_ID4
+        ],
+        [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_ID4
+        ],
+        [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_ID4
+        ],
+        [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 TransactionBlock3 ? new SuiKitTxBlock5(initTxBlock) : initTxBlock ? initTxBlock : new SuiKitTxBlock5();
+  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);
@@ -3630,8 +4138,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();
@@ -3903,11 +4411,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
@@ -4020,12 +4601,14 @@ export {
   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,
@@ -4033,10 +4616,11 @@ export {
   ScallopQuery,
   ScallopUtils,
   assetCoins,
+  borrowIncentiveRewardCoins,
   coinDecimals,
   coinIds,
   marketCoins,
-  rewardCoins,
+  spoolRewardCoins,
   stakeMarketCoins,
   voloCoinIds,
   wormholeCoinIds