@scallop-io/sui-scallop-sdk 0.44.17 → 0.44.19

package/dist/index.mjs

@@ -1,9 +1,12 @@
 // src/constants/common.ts
 var API_BASE_URL = "https://sui.api.scallop.io";
 var SDK_API_BASE_URL = "https://sdk.api.scallop.io";
-var ADDRESSES_ID = "6462a088a7ace142bb6d7e9b";
-var PROTOCOL_OBJECT_ID = "0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf";
-var BORROW_FEE_PROTOCOL_ID = "0xc38f849e81cfe46d4e4320f508ea7dda42934a329d5a6571bb4c3cb6ea63f5da";
+var IS_VE_SCA_TEST = false;
+var ADDRESSES_ID = IS_VE_SCA_TEST ? "65fb07c39c845425d71d7b18" : "6601955b8b0024600a917079";
+var PROTOCOL_OBJECT_ID = IS_VE_SCA_TEST ? "0xc9f859f98ca352a11b97a038c4b4162bee437b8df8caa047990fe9cb03d4f778" : "0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf";
+var BORROW_FEE_PROTOCOL_ID = IS_VE_SCA_TEST ? "0xc9f859f98ca352a11b97a038c4b4162bee437b8df8caa047990fe9cb03d4f778" : "0xc38f849e81cfe46d4e4320f508ea7dda42934a329d5a6571bb4c3cb6ea63f5da";
+var SCA_COIN_TYPE = IS_VE_SCA_TEST ? `0x6cd813061a3adf3602b76545f076205f0c8e7ec1d3b1eab9a1da7992c18c0524::sca::SCA` : "0x7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6::sca::SCA";
+var OLD_BORROW_INCENTIVE_PROTOCOL_ID = "0xc63072e7f5f4983a2efaf5bdba1480d5e7d74d57948e1c7cc436f8e22cbeb410";
 var SUPPORT_POOLS = [
   "eth",
   "btc",
@@ -42,7 +45,7 @@ var SUPPORT_SPOOLS = [
 ];
 var SUPPORT_SPOOLS_REWARDS = ["sui"];
 var SUPPORT_BORROW_INCENTIVE_POOLS = ["sui", "usdc", "usdt"];
-var SUPPORT_BORROW_INCENTIVE_REWARDS = ["sui"];
+var SUPPORT_BORROW_INCENTIVE_REWARDS = ["sui", "sca"];
 var SUPPORT_ORACLES = ["supra", "switchboard", "pyth"];
 var SUPPORT_PACKAGES = [
   "coinDecimalsRegistry",
@@ -82,7 +85,8 @@ var coinDecimals = {
   scetus: 9,
   safsui: 9,
   shasui: 9,
-  svsui: 9
+  svsui: 9,
+  sca: 9
 };
 var assetCoins = {
   eth: "eth",
@@ -95,7 +99,8 @@ var assetCoins = {
   cetus: "cetus",
   afsui: "afsui",
   hasui: "hasui",
-  vsui: "vsui"
+  vsui: "vsui",
+  sca: "sca"
 };
 var marketCoins = {
   seth: "seth",
@@ -131,9 +136,9 @@ var spoolRewardCoins = {
   svsui: "sui"
 };
 var borrowIncentiveRewardCoins = {
-  sui: "sui",
-  usdc: "sui",
-  usdt: "sui"
+  sui: ["sui", "sca"],
+  usdc: ["sui", "sca"],
+  usdt: ["sui", "sca"]
 };
 var coinIds = {
   sui: "0x0000000000000000000000000000000000000000000000000000000000000002",
@@ -146,7 +151,8 @@ var coinIds = {
   cetus: "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b",
   afsui: "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc",
   hasui: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d",
-  vsui: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55"
+  vsui: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55",
+  sca: IS_VE_SCA_TEST ? "0x6cd813061a3adf3602b76545f076205f0c8e7ec1d3b1eab9a1da7992c18c0524" : "0x7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6"
 };
 var wormholeCoinIds = {
   eth: "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5",
@@ -160,6 +166,13 @@ var voloCoinIds = {
   vsui: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55"
 };
 
+// src/constants/vesca.ts
+var UNLOCK_ROUND_DURATION = 60 * 60 * 24;
+var MAX_LOCK_ROUNDS = 1460;
+var MAX_LOCK_DURATION = MAX_LOCK_ROUNDS * UNLOCK_ROUND_DURATION;
+var MIN_INITIAL_LOCK_AMOUNT = 1e10;
+var MIN_TOP_UP_AMOUNT = 1e9;
+
 // src/models/scallop.ts
 import { SuiKit as SuiKit5 } from "@scallop-io/sui-kit";
 
@@ -388,8 +401,17 @@ var EMPTY_ADDRESSES = {
     adminCap: "",
     object: "",
     query: "",
+    config: "",
     incentivePools: "",
     incentiveAccounts: ""
+  },
+  vesca: {
+    id: "",
+    adminCap: "",
+    tableId: "",
+    table: "",
+    treasury: "",
+    config: ""
   }
 };
 var ScallopAddress = class {
@@ -717,10 +739,96 @@ var requireSender = (txBlock) => {
   }
   return sender;
 };
+var checkLockSca = (scaAmountOrCoin, lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInSecondTimestamp) => {
+  const isInitialLock = !prevUnlockAtInSecondTimestamp;
+  const isLockExpired = !isInitialLock && prevUnlockAtInSecondTimestamp * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
+  if (isInitialLock || isLockExpired) {
+    if (scaAmountOrCoin !== void 0 && lockPeriodInDays !== void 0) {
+      if (lockPeriodInDays <= 0) {
+        throw new Error("Lock period must be greater than 0");
+      }
+      if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_INITIAL_LOCK_AMOUNT) {
+        throw new Error(
+          `Minimum lock amount for ${isLockExpired ? "renewing expired veSca" : "initial lock"} is 10 SCA`
+        );
+      }
+      const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
+      if (extendLockPeriodInSecond > MAX_LOCK_DURATION) {
+        throw new Error(
+          `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days)`
+        );
+      }
+    } else {
+      throw new Error(
+        `SCA amount and lock period is required for ${isLockExpired ? "renewing expired veSca" : "initial lock"}`
+      );
+    }
+  } else {
+    checkVesca(prevUnlockAtInSecondTimestamp);
+    if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_TOP_UP_AMOUNT) {
+      throw new Error("Minimum top up amount is 1 SCA");
+    }
+    if (!!newUnlockAtInSecondTimestamp && !!prevUnlockAtInSecondTimestamp) {
+      const totalLockDuration = newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp;
+      if (totalLockDuration > MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
+        throw new Error(
+          `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
+        );
+      }
+    }
+  }
+};
+var checkExtendLockPeriod = (lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInSecondTimestamp) => {
+  checkVesca(prevUnlockAtInSecondTimestamp);
+  if (lockPeriodInDays <= 0) {
+    throw new Error("Lock period must be greater than 0");
+  }
+  const isInitialLock = !prevUnlockAtInSecondTimestamp;
+  const isLockExpired = !isInitialLock && prevUnlockAtInSecondTimestamp * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
+  if (isLockExpired) {
+    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
+  }
+  if (prevUnlockAtInSecondTimestamp) {
+    const totalLockDuration = newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp;
+    if (totalLockDuration > MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
+      throw new Error(
+        `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
+      );
+    }
+  }
+};
+var checkExtendLockAmount = (scaAmount, prevUnlockAtInSecondTimestamp) => {
+  checkVesca(prevUnlockAtInSecondTimestamp);
+  if (scaAmount < MIN_TOP_UP_AMOUNT) {
+    throw new Error("Minimum top up amount is 1 SCA");
+  }
+  const isInitialLock = !prevUnlockAtInSecondTimestamp;
+  const isLockExpired = !isInitialLock && prevUnlockAtInSecondTimestamp * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
+  if (isLockExpired) {
+    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
+  }
+};
+var checkRenewExpiredVeSca = (scaAmount, lockPeriodInDays, prevUnlockAtInSecondTimestamp) => {
+  checkVesca(prevUnlockAtInSecondTimestamp);
+  if (scaAmount < MIN_INITIAL_LOCK_AMOUNT) {
+    throw new Error("Minimum lock amount for renewing expired vesca 10 SCA");
+  }
+  const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
+  if (extendLockPeriodInSecond >= MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
+    throw new Error(
+      `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
+    );
+  }
+};
+var checkVesca = (prevUnlockAtInSecondTimestamp) => {
+  if (prevUnlockAtInSecondTimestamp === void 0) {
+    throw new Error("veSca not found");
+  }
+};
 
 // src/utils/query.ts
 import BigNumber from "bignumber.js";
-import { normalizeStructTag } from "@mysten/sui.js/utils";
+import { normalizeStructTag, parseStructTag } from "@mysten/sui.js/utils";
 var parseOriginMarketPoolData = (originMarketPoolData) => {
   return {
     coinType: normalizeStructTag(originMarketPoolData.type.name),
@@ -936,7 +1044,10 @@ var calculateSpoolRewardPoolData = (parsedSpoolData, parsedSpoolRewardPoolData,
   );
   const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
   const rewardValueForYear = BigNumber(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
-  const rewardRate = rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).toNumber() : Infinity;
+  let rewardRate = rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).toNumber() : Infinity;
+  if (parsedSpoolData.maxPoint === parsedSpoolData.distributedPoint) {
+    rewardRate = Infinity;
+  }
   return {
     rewardApr: rewardRate,
     totalRewardAmount: totalRewardAmount.toNumber(),
@@ -951,119 +1062,112 @@ var calculateSpoolRewardPoolData = (parsedSpoolData, parsedSpoolRewardPoolData,
     rewardPerSec: rewardPerSec.toNumber()
   };
 };
+var parseOriginBorrowIncentivesPoolPointData = (originBorrowIncentivePoolPointData) => {
+  return {
+    pointType: normalizeStructTag(
+      originBorrowIncentivePoolPointData.point_type.name
+    ),
+    distributedPointPerPeriod: Number(
+      originBorrowIncentivePoolPointData.distributed_point_per_period
+    ),
+    period: Number(originBorrowIncentivePoolPointData.point_distribution_time),
+    distributedPoint: Number(
+      originBorrowIncentivePoolPointData.distributed_point
+    ),
+    points: Number(originBorrowIncentivePoolPointData.points),
+    index: Number(originBorrowIncentivePoolPointData.index),
+    baseWeight: Number(originBorrowIncentivePoolPointData.base_weight),
+    weightedAmount: Number(originBorrowIncentivePoolPointData.weighted_amount),
+    lastUpdate: Number(originBorrowIncentivePoolPointData.last_update)
+  };
+};
 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),
+    minStakes: Number(originBorrowIncentivePoolData.min_stakes),
+    maxStakes: Number(originBorrowIncentivePoolData.max_stakes),
     staked: Number(originBorrowIncentivePoolData.stakes),
-    index: Number(originBorrowIncentivePoolData.index),
     createdAt: Number(originBorrowIncentivePoolData.created_at),
-    lastUpdate: Number(originBorrowIncentivePoolData.last_update)
+    poolPoints: originBorrowIncentivePoolData.points.reduce(
+      (acc, point) => {
+        const parsed = parseOriginBorrowIncentivesPoolPointData(point);
+        const name = parseStructTag(
+          parsed.pointType
+        ).name.toLowerCase();
+        acc[name] = parsed;
+        return acc;
+      },
+      {}
+    )
   };
 };
-var calculateBorrowIncentivePoolData = (parsedBorrowIncentivePoolData, borrowIncentiveCoinPrice, borrowIncentiveCoinDecimal) => {
+var calculateBorrowIncentivePoolPointData = (pasredBorrowIncentinvePoolData, parsedBorrowIncentivePoolPointData, rewardCoinPrice, rewardCoinDecimal, poolCoinPrice, poolCoinDecimal) => {
   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();
+    parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
+  ).dividedBy(parsedBorrowIncentivePoolPointData.period);
   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);
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedBorrowIncentivePoolPointData.lastUpdate
+  ).dividedBy(parsedBorrowIncentivePoolPointData.period).toFixed(0);
   const accumulatedPoints = BigNumber.minimum(
     BigNumber(timeDelta).multipliedBy(
-      parsedBorrowIncentivePoolData.pointPerPeriod
+      parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
     ),
-    remainingPoints
+    BigNumber(parsedBorrowIncentivePoolPointData.points)
   );
-  const currentPointIndex = BigNumber(parsedBorrowIncentivePoolData.index).plus(
-    accumulatedPoints.dividedBy(parsedBorrowIncentivePoolData.staked).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedBorrowIncentivePoolData.staked) : 0
+  const currentPointIndex = BigNumber(
+    parsedBorrowIncentivePoolPointData.index
+  ).plus(
+    accumulatedPoints.dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount) : 0
   );
   const currentTotalDistributedPoint = BigNumber(
-    parsedBorrowIncentivePoolData.distributedPoint
+    parsedBorrowIncentivePoolPointData.distributedPoint
   ).plus(accumulatedPoints);
-  const stakedAmount = BigNumber(parsedBorrowIncentivePoolData.staked);
-  const stakedCoin = stakedAmount.shiftedBy(-1 * borrowIncentiveCoinDecimal);
-  const stakedValue = stakedCoin.multipliedBy(borrowIncentiveCoinPrice);
+  const stakedAmount = BigNumber(pasredBorrowIncentinvePoolData.staked);
+  const stakedCoin = stakedAmount.shiftedBy(-1 * poolCoinDecimal);
+  const stakedValue = stakedCoin.multipliedBy(poolCoinPrice);
+  const baseWeight = BigNumber(parsedBorrowIncentivePoolPointData.baseWeight);
+  const weightedStakedAmount = BigNumber(
+    parsedBorrowIncentivePoolPointData.weightedAmount
+  );
+  const weightedStakedCoin = weightedStakedAmount.shiftedBy(
+    -1 * poolCoinDecimal
+  );
+  const weightedStakedValue = weightedStakedCoin.multipliedBy(poolCoinPrice);
+  const rateYearFactor = 365 * 24 * 60 * 60;
+  const rewardPerSec = BigNumber(distributedPointPerSec).dividedBy(
+    parsedBorrowIncentivePoolPointData.period
+  );
+  const rewardValueForYear = BigNumber(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
+  const weightScale = BigNumber("1000000000000");
+  const rewardRate = rewardValueForYear.dividedBy(weightedStakedValue).multipliedBy(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(weightScale).isFinite() ? rewardValueForYear.dividedBy(weightedStakedValue).multipliedBy(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(weightScale).toNumber() : Infinity;
   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()
+    stakedValue: stakedValue.toNumber(),
+    baseWeight: baseWeight.toNumber(),
+    weightedStakedAmount: weightedStakedAmount.toNumber(),
+    weightedStakedCoin: weightedStakedCoin.toNumber(),
+    weightedStakedValue: weightedStakedValue.toNumber(),
+    rewardApr: rewardRate,
+    rewardPerSec: rewardPerSec.toNumber()
   };
 };
-var parseOriginBorrowIncentiveRewardPoolData = (originBorrowIncentiveRewardPoolData) => {
+var parseOriginBorrowIncentiveAccountPoolPointData = (originBorrowIncentiveAccountPoolPointData) => {
   return {
-    rewardType: normalizeStructTag(
-      originBorrowIncentiveRewardPoolData.reward_type.name
+    pointType: normalizeStructTag(
+      originBorrowIncentiveAccountPoolPointData.point_type.name
     ),
-    claimedRewards: Number(originBorrowIncentiveRewardPoolData.claimed_rewards),
-    exchangeRateNumerator: Number(
-      originBorrowIncentiveRewardPoolData.exchange_rate_numerator
-    ),
-    exchangeRateDenominator: Number(
-      originBorrowIncentiveRewardPoolData.exchange_rate_denominator
+    weightedAmount: Number(
+      originBorrowIncentiveAccountPoolPointData.weighted_amount
     ),
-    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()
+    points: Number(originBorrowIncentiveAccountPoolPointData.points),
+    totalPoints: Number(originBorrowIncentiveAccountPoolPointData.total_points),
+    index: Number(originBorrowIncentiveAccountPoolPointData.index)
   };
 };
 var parseOriginBorrowIncentiveAccountData = (originBorrowIncentiveAccountData) => {
@@ -1071,10 +1175,18 @@ var parseOriginBorrowIncentiveAccountData = (originBorrowIncentiveAccountData) =
     poolType: normalizeStructTag(
       originBorrowIncentiveAccountData.pool_type.name
     ),
-    amount: Number(originBorrowIncentiveAccountData.amount),
-    index: Number(originBorrowIncentiveAccountData.index),
-    points: Number(originBorrowIncentiveAccountData.points),
-    totalPoints: Number(originBorrowIncentiveAccountData.total_points)
+    debtAmount: Number(originBorrowIncentiveAccountData.debt_amount),
+    pointList: originBorrowIncentiveAccountData.points_list.reduce(
+      (acc, point) => {
+        const parsed = parseOriginBorrowIncentiveAccountPoolPointData(point);
+        const name = parseStructTag(
+          parsed.pointType
+        ).name.toLowerCase();
+        acc[name] = parsed;
+        return acc;
+      },
+      {}
+    )
   };
 };
 var minBigNumber = (...args) => {
@@ -1102,7 +1214,8 @@ var isMarketCoin = (coinName) => {
     .../* @__PURE__ */ new Set([
       ...SUPPORT_POOLS,
       ...SUPPORT_COLLATERALS,
-      ...SUPPORT_SPOOLS_REWARDS
+      ...SUPPORT_SPOOLS_REWARDS,
+      ...SUPPORT_BORROW_INCENTIVE_REWARDS
     ])
   ].includes(assetCoinName);
 };
@@ -1136,6 +1249,19 @@ var parseDataFromPythPriceFeed = (feed, address) => {
     throw new Error("Invalid feed id");
   }
 };
+var findClosestUnlockRound = (unlockAtInSecondTimestamp) => {
+  const unlockDate = new Date(unlockAtInSecondTimestamp * 1e3);
+  const closestTwelveAM = new Date(unlockAtInSecondTimestamp * 1e3);
+  closestTwelveAM.setUTCHours(0, 0, 0, 0);
+  if (unlockDate.getUTCHours() >= 0) {
+    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() + 1);
+  }
+  const now = (/* @__PURE__ */ new Date()).getTime();
+  if (closestTwelveAM.getTime() - now > MAX_LOCK_DURATION * 1e3) {
+    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() - 1);
+  }
+  return Math.floor(closestTwelveAM.getTime() / 1e3);
+};
 
 // src/queries/coreQuery.ts
 var queryMarket = async (query, indexer = false) => {
@@ -1324,7 +1450,7 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
       const fields = marketObject.content.fields;
       const coinType = query.utils.parseCoinType(poolCoinName);
       const balanceSheetParentId = fields.vault.fields.balance_sheets.fields.table.fields.id.id;
-      const balanceSheetDdynamicFieldObjectResponse = await query.suiKit.client().getDynamicFieldObject({
+      const balanceSheetDynamicFieldObjectResponse = await query.suiKit.client().getDynamicFieldObject({
         parentId: balanceSheetParentId,
         name: {
           type: "0x1::type_name::TypeName",
@@ -1333,9 +1459,9 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
           }
         }
       });
-      const balanceSheetDdynamicFieldObject = balanceSheetDdynamicFieldObjectResponse.data;
-      if (balanceSheetDdynamicFieldObject && balanceSheetDdynamicFieldObject.content && "fields" in balanceSheetDdynamicFieldObject.content) {
-        const dynamicFields = balanceSheetDdynamicFieldObject.content.fields;
+      const balanceSheetDynamicFieldObject = balanceSheetDynamicFieldObjectResponse.data;
+      if (balanceSheetDynamicFieldObject && balanceSheetDynamicFieldObject.content && "fields" in balanceSheetDynamicFieldObject.content) {
+        const dynamicFields = balanceSheetDynamicFieldObject.content.fields;
         balanceSheet = dynamicFields.value.fields;
       }
       const borrowIndexParentId = fields.borrow_dynamics.fields.table.fields.id.id;
@@ -1495,7 +1621,7 @@ var getMarketCollateral = async (query, collateralCoinName, indexer = false, mar
       const fields = marketObject.content.fields;
       const coinType = query.utils.parseCoinType(collateralCoinName);
       const riskModelParentId = fields.risk_models.fields.table.fields.id.id;
-      const riskModelDdynamicFieldObjectResponse = await query.suiKit.client().getDynamicFieldObject({
+      const riskModelDynamicFieldObjectResponse = await query.suiKit.client().getDynamicFieldObject({
         parentId: riskModelParentId,
         name: {
           type: "0x1::type_name::TypeName",
@@ -1504,9 +1630,9 @@ var getMarketCollateral = async (query, collateralCoinName, indexer = false, mar
           }
         }
       });
-      const riskModelDdynamicFieldObject = riskModelDdynamicFieldObjectResponse.data;
-      if (riskModelDdynamicFieldObject && riskModelDdynamicFieldObject.content && "fields" in riskModelDdynamicFieldObject.content) {
-        const dynamicFields = riskModelDdynamicFieldObject.content.fields;
+      const riskModelDynamicFieldObject = riskModelDynamicFieldObjectResponse.data;
+      if (riskModelDynamicFieldObject && riskModelDynamicFieldObject.content && "fields" in riskModelDynamicFieldObject.content) {
+        const dynamicFields = riskModelDynamicFieldObject.content.fields;
         riskModel = dynamicFields.value.fields;
       }
       const collateralStatParentId = fields.collateral_stats.fields.table.fields.id.id;
@@ -2176,71 +2302,70 @@ var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames, indexer
   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"]);
+  txBlock.moveCall(queryTarget, [incentivePoolsId]);
   const queryResult = await query.suiKit.inspectTxn(txBlock);
   const borrowIncentivePoolsQueryData = queryResult.events[0].parsedJson;
-  const parsedBorrowIncentiveRewardPoolData = parseOriginBorrowIncentiveRewardPoolData(
-    borrowIncentivePoolsQueryData.reward_pool
-  );
-  const rewardCoinType = parsedBorrowIncentiveRewardPoolData.rewardType;
-  const rewardCoinName = query.utils.parseCoinNameFromType(rewardCoinType);
-  const coinPrices = await query.utils.getCoinPrices(
-    [.../* @__PURE__ */ new Set([...borrowIncentiveCoinNames, rewardCoinName])]
-  );
   const borrowIncentivePools = {};
   if (indexer) {
-    const borrowIncentivePoolsIndexer = await query.indexer.getBorrowIncentivePools();
-    for (const borrowIncentivePool of Object.values(
-      borrowIncentivePoolsIndexer
-    )) {
-      if (!borrowIncentiveCoinNames.includes(borrowIncentivePool.coinName))
-        continue;
-      borrowIncentivePool.coinPrice = coinPrices[borrowIncentivePool.coinName] || borrowIncentivePool.coinPrice;
-      borrowIncentivePool.rewardCoinPrice = coinPrices[rewardCoinName] || borrowIncentivePool.rewardCoinPrice;
-      borrowIncentivePools[borrowIncentivePool.coinName] = borrowIncentivePool;
-    }
-    return borrowIncentivePools;
   }
   for (const pool of borrowIncentivePoolsQueryData.incentive_pools) {
-    const coinType = normalizeStructTag4(pool.pool_type.name);
-    const coinName = query.utils.parseCoinNameFromType(coinType);
-    const rewardCoinName2 = query.utils.parseCoinNameFromType(rewardCoinType);
-    if (!borrowIncentiveCoinNames.includes(coinName)) {
-      continue;
-    }
+    const borrowIncentivePoolPoints = {};
     const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(pool);
-    const coinPrice = coinPrices?.[coinName] ?? 0;
-    const coinDecimal = query.utils.getCoinDecimal(coinName);
-    const calculatedBorrowIncentivePoolData = calculateBorrowIncentivePoolData(
-      parsedBorrowIncentivePoolData,
-      coinPrice,
-      coinDecimal
+    const coinPrices = await query.utils.getCoinPrices(
+      [
+        .../* @__PURE__ */ new Set([
+          ...borrowIncentiveCoinNames,
+          ...SUPPORT_BORROW_INCENTIVE_REWARDS
+        ])
+      ]
     );
-    const rewardCoinPrice = coinPrices?.[rewardCoinName2] ?? 0;
-    const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName2);
-    const calculatedBorrowIncentiveRewardPoolData = calculateBorrowIncentiveRewardPoolData(
-      parsedBorrowIncentivePoolData,
-      parsedBorrowIncentiveRewardPoolData,
-      calculatedBorrowIncentivePoolData,
-      rewardCoinPrice,
-      rewardCoinDecimal
+    const poolCoinType = normalizeStructTag4(pool.pool_type.name);
+    const poolCoinName = query.utils.parseCoinNameFromType(
+      poolCoinType
     );
-    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
+    const poolCoinPrice = coinPrices?.[poolCoinName] ?? 0;
+    const poolCoinDecimal = query.utils.getCoinDecimal(poolCoinName);
+    if (!borrowIncentiveCoinNames.includes(poolCoinName)) {
+      continue;
+    }
+    for (const [coinName, poolPoint] of Object.entries(
+      parsedBorrowIncentivePoolData.poolPoints
+    )) {
+      const rewardCoinType = normalizeStructTag4(poolPoint.pointType);
+      const rewardCoinName = query.utils.parseCoinNameFromType(
+        rewardCoinType
+      );
+      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+      const symbol = query.utils.parseSymbol(rewardCoinName);
+      const coinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+      const calculatedPoolPoint = calculateBorrowIncentivePoolPointData(
+        parsedBorrowIncentivePoolData,
+        poolPoint,
+        rewardCoinPrice,
+        rewardCoinDecimal,
+        poolCoinPrice,
+        poolCoinDecimal
+      );
+      borrowIncentivePoolPoints[coinName] = {
+        symbol,
+        coinName: rewardCoinName,
+        coinType: rewardCoinType,
+        coinDecimal,
+        coinPrice: rewardCoinPrice,
+        points: poolPoint.points,
+        distributedPoint: poolPoint.distributedPoint,
+        weightedAmount: poolPoint.weightedAmount,
+        ...calculatedPoolPoint
+      };
+    }
+    borrowIncentivePools[poolCoinName] = {
+      coinName: poolCoinName,
+      symbol: query.utils.parseSymbol(poolCoinName),
+      coinType: poolCoinType,
+      coinDecimal: poolCoinDecimal,
+      coinPrice: poolCoinPrice,
+      points: borrowIncentivePoolPoints
     };
   }
   return borrowIncentivePools;
@@ -2259,19 +2384,13 @@ var queryBorrowIncentiveAccounts = async (query, obligationId, borrowIncentiveCo
   const queryResult = await query.suiKit.inspectTxn(txBlock);
   const borrowIncentiveAccountsQueryData = queryResult.events[0].parsedJson;
   const borrowIncentiveAccounts = Object.values(
-    borrowIncentiveAccountsQueryData.incentive_states
+    borrowIncentiveAccountsQueryData.pool_records
   ).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
-      };
+      accounts[coinName] = parsedBorrowIncentiveAccount;
     }
     return accounts;
   }, {});
@@ -2491,9 +2610,8 @@ var getObligationAccounts = async (query, ownerAddress, indexer = false) => {
 };
 var getObligationAccount = async (query, obligationId, ownerAddress, indexer = false, market, coinPrices, coinAmounts) => {
   market = market || await query.queryMarket(indexer);
-  const assetCoinNames = [
+  const collateralAssetCoinNames = [
     .../* @__PURE__ */ new Set([
-      ...Object.values(market.pools).map((pool) => pool.coinName),
       ...Object.values(market.collaterals).map(
         (collateral) => collateral.coinName
       )
@@ -2505,8 +2623,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
     indexer
   );
   const borrowIncentiveAccounts = await query.getBorrowIncentiveAccounts(obligationId);
-  coinPrices = coinPrices || await query.utils.getCoinPrices(assetCoinNames);
-  coinAmounts = coinAmounts || await query.getCoinAmounts(assetCoinNames, ownerAddress);
+  coinPrices = coinPrices || await query.utils.getCoinPrices(collateralAssetCoinNames);
+  coinAmounts = coinAmounts || await query.getCoinAmounts(collateralAssetCoinNames, ownerAddress);
   const collaterals = {};
   const debts = {};
   const borrowIncentives = {};
@@ -2517,7 +2635,7 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
   let totalBorrowedPools = 0;
   let totalBorrowedValue = BigNumber3(0);
   let totalBorrowedValueWithWeight = BigNumber3(0);
-  for (const assetCoinName of assetCoinNames) {
+  for (const assetCoinName of collateralAssetCoinNames) {
     const collateral = obligationQuery.collaterals.find((collateral2) => {
       const collateralCoinName = query.utils.parseCoinNameFromType(
         collateral2.type.name
@@ -2574,7 +2692,10 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
       };
     }
   }
-  for (const assetCoinName of assetCoinNames) {
+  const borrowAssetCoinNames = [
+    .../* @__PURE__ */ new Set([...Object.values(market.pools).map((pool) => pool.coinName)])
+  ];
+  for (const assetCoinName of borrowAssetCoinNames) {
     const debt = obligationQuery.debts.find((debt2) => {
       const poolCoinName = query.utils.parseCoinNameFromType(
         debt2.type.name
@@ -2633,34 +2754,51 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
   )) {
     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()
-        };
+      const rewards = [];
+      for (const rewardCoinName of SUPPORT_BORROW_INCENTIVE_REWARDS) {
+        const accountPoint = borrowIncentiveAccount.pointList[rewardCoinName];
+        const poolPoint = borrowIncentivePool.points[rewardCoinName];
+        if (accountPoint && poolPoint) {
+          let availableClaimAmount = BigNumber3(0);
+          let availableClaimCoin = BigNumber3(0);
+          const accountBorrowedAmount = BigNumber3(accountPoint.weightedAmount);
+          const baseIndexRate = 1e9;
+          const increasedPointRate = poolPoint.currentPointIndex ? BigNumber3(
+            poolPoint.currentPointIndex - accountPoint.index
+          ).dividedBy(baseIndexRate) : 1;
+          availableClaimAmount = availableClaimAmount.plus(
+            accountBorrowedAmount.multipliedBy(increasedPointRate).plus(accountPoint.points)
+          );
+          availableClaimCoin = availableClaimAmount.shiftedBy(
+            -1 * poolPoint.coinDecimal
+          );
+          const weightScale = BigNumber3("1000000000000");
+          const boostValue = BigNumber3(accountPoint.weightedAmount).div(
+            BigNumber3(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
+          ).toNumber();
+          if (availableClaimAmount.isGreaterThan(0)) {
+            rewards.push({
+              coinName: poolPoint.coinName,
+              coinType: poolPoint.coinType,
+              symbol: poolPoint.symbol,
+              coinDecimal: poolPoint.coinDecimal,
+              coinPrice: poolPoint.coinPrice,
+              availableClaimAmount: availableClaimAmount.toNumber(),
+              availableClaimCoin: availableClaimCoin.toNumber(),
+              boostValue
+            });
+          }
+        }
       }
+      borrowIncentives[coinName] = {
+        coinName: borrowIncentivePool.coinName,
+        coinType: borrowIncentivePool.coinType,
+        symbol: borrowIncentivePool.symbol,
+        coinDecimal: borrowIncentivePool.coinDecimal,
+        coinPrice: borrowIncentivePool.coinPrice,
+        rewards
+      };
     }
   }
   let riskLevel = totalRequiredCollateralValue.isZero() ? BigNumber3(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
@@ -2788,6 +2926,70 @@ var getTotalValueLocked = async (query, indexer = false) => {
   return tvl;
 };
 
+// src/queries/vescaQuery.ts
+import BigNumber4 from "bignumber.js";
+var getVescaKeys = async (query, ownerAddress) => {
+  const owner = ownerAddress || query.suiKit.currentAddress();
+  const veScaPkgId = IS_VE_SCA_TEST ? "0xb220d034bdf335d77ae5bfbf6daf059c2cc7a1f719b12bfed75d1736fac038c8" : query.address.get("vesca.id");
+  const veScaKeyType = `${veScaPkgId}::ve_sca::VeScaKey`;
+  const keyObjectsResponse = [];
+  let hasNextPage = false;
+  let nextCursor = null;
+  do {
+    const paginatedKeyObjectsResponse = await query.suiKit.client().getOwnedObjects({
+      owner,
+      filter: {
+        StructType: veScaKeyType
+      },
+      cursor: nextCursor
+    });
+    keyObjectsResponse.push(...paginatedKeyObjectsResponse.data);
+    if (paginatedKeyObjectsResponse.hasNextPage && paginatedKeyObjectsResponse.nextCursor) {
+      hasNextPage = true;
+      nextCursor = paginatedKeyObjectsResponse.nextCursor;
+    } else {
+      hasNextPage = false;
+    }
+  } while (hasNextPage);
+  const keyObjectDatas = keyObjectsResponse.map((objResponse) => objResponse.data).filter((data) => !!data);
+  return keyObjectDatas;
+};
+var getVeScas = async (query, ownerAddress) => {
+  const keyObjectDatas = await getVescaKeys(query, ownerAddress);
+  const keyObjectId = keyObjectDatas.map((data) => data.objectId);
+  const veScas = [];
+  for (const keyId of keyObjectId) {
+    const veSca = await getVeSca(query, keyId);
+    if (veSca)
+      veScas.push(veSca);
+  }
+  return veScas;
+};
+var getVeSca = async (query, veScaKeyId, ownerAddress) => {
+  const tableId = IS_VE_SCA_TEST ? "0xc607241e4a679fe376d1170b2fbe07b64917bfe69100d4825241cda20039d4bd" : query.address.get(`vesca.tableId`);
+  veScaKeyId = veScaKeyId || (await getVescaKeys(query, ownerAddress))[0].objectId;
+  let vesca = void 0;
+  const veScaDynamicFieldObjectResponse = await query.suiKit.client().getDynamicFieldObject({
+    parentId: tableId,
+    name: {
+      type: "0x2::object::ID",
+      value: veScaKeyId
+    }
+  });
+  const veScaDynamicFieldObject = veScaDynamicFieldObjectResponse.data;
+  if (veScaDynamicFieldObject && veScaDynamicFieldObject.content && veScaDynamicFieldObject.content.dataType === "moveObject" && "fields" in veScaDynamicFieldObject.content) {
+    const dynamicFields = veScaDynamicFieldObject.content.fields.value.fields;
+    vesca = {
+      id: veScaDynamicFieldObject.objectId,
+      keyId: veScaKeyId,
+      lockedScaAmount: BigNumber4(dynamicFields.locked_sca_amount).toNumber(),
+      lockedScaCoin: BigNumber4(dynamicFields.locked_sca_amount).shiftedBy(-9).toNumber(),
+      unlockAt: BigNumber4(dynamicFields.unlock_at).toNumber()
+    };
+  }
+  return vesca;
+};
+
 // src/models/scallopIndexer.ts
 import axios2 from "axios";
 var ScallopIndexer = class {
@@ -3630,6 +3832,38 @@ var ScallopUtils = class {
   parseApyToApr(apy, compoundFrequency = 365) {
     return ((1 + apy) ** (1 / compoundFrequency) - 1) * compoundFrequency;
   }
+  /**
+   * Give extend lock period to get unlock at in seconds timestamp.
+   *
+   * @description
+   * - When the user without remaining unlock period, If the extended unlock day is not specified,
+   *   the unlock period will be increased by one day by default.
+   * - When the given extended day plus the user's remaining unlock period exceeds the maximum
+   *    unlock period, the maximum unlock period is used as unlock period.
+   *
+   * @param extendLockPeriodInDay The extend lock period in day.
+   * @param unlockAtInSecondTimestamp The unlock timestamp from veSca object.
+   * @return New unlock at in seconds timestamp.
+   */
+  getUnlockAt(extendLockPeriodInDay, unlockAtInSecondTimestamp) {
+    const now = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+    const remainingLockPeriod = unlockAtInSecondTimestamp ? Math.max(unlockAtInSecondTimestamp - now, 0) : 0;
+    let newUnlockAtInSecondTimestamp = 0;
+    if (remainingLockPeriod === 0) {
+      const lockPeriod = (extendLockPeriodInDay ?? 1) * UNLOCK_ROUND_DURATION;
+      newUnlockAtInSecondTimestamp = Math.min(
+        now + lockPeriod,
+        now + MAX_LOCK_DURATION
+      );
+    } else {
+      const lockPeriod = Math.min(
+        extendLockPeriodInDay ? extendLockPeriodInDay * UNLOCK_ROUND_DURATION + remainingLockPeriod : remainingLockPeriod,
+        MAX_LOCK_DURATION
+      );
+      newUnlockAtInSecondTimestamp = now + lockPeriod;
+    }
+    return findClosestUnlockRound(newUnlockAtInSecondTimestamp);
+  }
 };
 
 // src/models/scallopBuilder.ts
@@ -4290,9 +4524,282 @@ 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";
+import { TransactionBlock as TransactionBlock4 } from "@mysten/sui.js/transactions";
+import { SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID5 } from "@mysten/sui.js/utils";
+import { SuiTxBlock as SuiKitTxBlock6 } from "@scallop-io/sui-kit";
+
+// src/builders/vescaBuilder.ts
+import {
+  SUI_CLOCK_OBJECT_ID as SUI_CLOCK_OBJECT_ID4,
+  TransactionBlock as TransactionBlock3,
+  SuiTxBlock as SuiKitTxBlock5
+} from "@scallop-io/sui-kit";
+var requireVeSca = async (...params) => {
+  const [builder, txBlock, veScaKey] = params;
+  if (params.length === 3 && veScaKey && typeof veScaKey === "string") {
+    const veSca = await getVeSca(builder.query, veScaKey);
+    if (!veSca) {
+      return void 0;
+    }
+    return veSca;
+  }
+  const sender = requireSender(txBlock);
+  const veScas = await getVeScas(builder.query, sender);
+  if (veScas.length === 0) {
+    return void 0;
+  }
+  return veScas[0];
+};
+var generateNormalVeScaMethod = ({
+  builder,
+  txBlock
+}) => {
+  const veScaIds = {
+    pkgId: builder.address.get("vesca.id"),
+    table: builder.address.get("vesca.table"),
+    treasury: builder.address.get("vesca.treasury"),
+    config: builder.address.get("vesca.config")
+  };
+  return {
+    lockSca: (scaCoin, unlockAtInSecondTimestamp) => {
+      return txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::mint_ve_sca_key`,
+        [
+          veScaIds.config,
+          veScaIds.table,
+          veScaIds.treasury,
+          scaCoin,
+          unlockAtInSecondTimestamp,
+          SUI_CLOCK_OBJECT_ID4
+        ],
+        []
+      );
+    },
+    extendLockPeriod: (veScaKey, newUnlockAtInSecondTimestamp) => {
+      txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::extend_lock_period`,
+        [
+          veScaIds.config,
+          veScaKey,
+          veScaIds.table,
+          veScaIds.treasury,
+          newUnlockAtInSecondTimestamp,
+          SUI_CLOCK_OBJECT_ID4
+        ],
+        []
+      );
+    },
+    extendLockAmount: (veScaKey, scaCoin) => {
+      txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::lock_more_sca`,
+        [
+          veScaIds.config,
+          veScaKey,
+          veScaIds.table,
+          veScaIds.treasury,
+          scaCoin,
+          SUI_CLOCK_OBJECT_ID4
+        ],
+        []
+      );
+    },
+    renewExpiredVeSca: (veScaKey, scaCoin, newUnlockAtInSecondTimestamp) => {
+      txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::renew_expired_ve_sca`,
+        [
+          veScaIds.config,
+          veScaKey,
+          veScaIds.table,
+          veScaIds.treasury,
+          scaCoin,
+          newUnlockAtInSecondTimestamp,
+          SUI_CLOCK_OBJECT_ID4
+        ],
+        []
+      );
+    },
+    redeemSca: (veScaKey) => {
+      return txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::redeem`,
+        [
+          veScaIds.config,
+          veScaKey,
+          veScaIds.table,
+          veScaIds.treasury,
+          SUI_CLOCK_OBJECT_ID4
+        ],
+        []
+      );
+    }
+  };
+};
+var generateQuickVeScaMethod = ({
+  builder,
+  txBlock
+}) => {
+  return {
+    lockScaQuick: async (amountOrCoin, lockPeriodInDays, autoCheck = true) => {
+      const sender = requireSender(txBlock);
+      const veSca = await requireVeSca(builder, txBlock);
+      let scaCoin = void 0;
+      const transferObjects = [];
+      if (amountOrCoin !== void 0 && typeof amountOrCoin === "number") {
+        const coins = await builder.utils.selectCoinIds(
+          amountOrCoin,
+          SCA_COIN_TYPE,
+          sender
+        );
+        const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(
+          coins,
+          amountOrCoin
+        );
+        scaCoin = takeCoin;
+        transferObjects.push(leftCoin);
+      } else {
+        scaCoin = amountOrCoin;
+      }
+      const newUnlockAt = builder.utils.getUnlockAt(
+        lockPeriodInDays,
+        veSca?.unlockAt
+      );
+      if (autoCheck)
+        checkLockSca(
+          amountOrCoin,
+          lockPeriodInDays,
+          newUnlockAt,
+          veSca?.unlockAt
+        );
+      console.log(
+        new Date(newUnlockAt * 1e3).toLocaleString("en-CA", {
+          hour12: true
+        })
+      );
+      const isInitialLock = !veSca?.unlockAt;
+      const isLockExpired = !isInitialLock && veSca.unlockAt * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
+      if (isInitialLock || isLockExpired) {
+        if (scaCoin) {
+          if (isInitialLock) {
+            const veScaKey = txBlock.lockSca(scaCoin, newUnlockAt);
+            transferObjects.push(veScaKey);
+          } else {
+            if (veSca.lockedScaAmount !== 0) {
+              const unlockedSca = txBlock.redeemSca(veSca.keyId);
+              transferObjects.push(unlockedSca);
+            }
+            txBlock.renewExpiredVeSca(veSca.keyId, scaCoin, newUnlockAt);
+          }
+        }
+      } else {
+        if (!!scaCoin && !!lockPeriodInDays) {
+          txBlock.extendLockPeriod(veSca.keyId, newUnlockAt);
+          txBlock.extendLockAmount(veSca.keyId, scaCoin);
+        } else if (lockPeriodInDays) {
+          txBlock.extendLockPeriod(veSca.keyId, newUnlockAt);
+        } else if (scaCoin) {
+          txBlock.extendLockAmount(veSca.keyId, scaCoin);
+        }
+      }
+      if (transferObjects.length > 0) {
+        txBlock.transferObjects(transferObjects, sender);
+      }
+    },
+    extendLockPeriodQuick: async (lockPeriodInDays, veScaKey, autoCheck = true) => {
+      const veSca = await requireVeSca(builder, txBlock, veScaKey);
+      const newUnlockAt = builder.utils.getUnlockAt(lockPeriodInDays);
+      if (autoCheck)
+        checkExtendLockPeriod(lockPeriodInDays, newUnlockAt, veSca?.unlockAt);
+      if (veSca) {
+        txBlock.extendLockPeriod(veSca.keyId, newUnlockAt);
+      }
+    },
+    extendLockAmountQuick: async (scaAmount, veScaKey, autoCheck = true) => {
+      const sender = requireSender(txBlock);
+      const veSca = await requireVeSca(builder, txBlock, veScaKey);
+      if (autoCheck)
+        checkExtendLockAmount(scaAmount, veSca?.unlockAt);
+      if (veSca) {
+        const scaCoins = await builder.utils.selectCoinIds(
+          scaAmount,
+          SCA_COIN_TYPE,
+          sender
+        );
+        const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(
+          scaCoins,
+          scaAmount
+        );
+        txBlock.extendLockAmount(veSca.keyId, takeCoin);
+        txBlock.transferObjects([leftCoin], sender);
+      }
+    },
+    renewExpiredVeScaQuick: async (scaAmount, lockPeriodInDays, veScaKey, autoCheck = true) => {
+      const sender = requireSender(txBlock);
+      const veSca = await requireVeSca(builder, txBlock, veScaKey);
+      const newUnlockAt = builder.utils.getUnlockAt(
+        lockPeriodInDays,
+        veSca?.unlockAt
+      );
+      if (autoCheck)
+        checkRenewExpiredVeSca(scaAmount, lockPeriodInDays, veSca?.unlockAt);
+      if (veSca) {
+        const transferObjects = [];
+        if (veSca.lockedScaAmount !== 0) {
+          const unlockedSca = txBlock.redeemSca(veSca.keyId);
+          transferObjects.push(unlockedSca);
+        }
+        const scaCoins = await builder.utils.selectCoinIds(
+          scaAmount,
+          SCA_COIN_TYPE,
+          sender
+        );
+        const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(
+          scaCoins,
+          scaAmount
+        );
+        transferObjects.push(leftCoin);
+        txBlock.renewExpiredVeSca(veSca.keyId, takeCoin, newUnlockAt);
+        txBlock.transferObjects(transferObjects, sender);
+      }
+    },
+    redeemScaQuick: async (veScaKey) => {
+      const sender = requireSender(txBlock);
+      const veSca = await requireVeSca(builder, txBlock, veScaKey);
+      checkVesca(veSca?.unlockAt);
+      if (veSca) {
+        const sca = txBlock.redeemSca(veSca.keyId);
+        txBlock.transferObjects([sca], sender);
+      }
+    }
+  };
+};
+var newVeScaTxBlock = (builder, initTxBlock) => {
+  const txBlock = initTxBlock instanceof TransactionBlock3 ? new SuiKitTxBlock5(initTxBlock) : initTxBlock ? initTxBlock : new SuiKitTxBlock5();
+  const normalMethod = generateNormalVeScaMethod({
+    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 = generateQuickVeScaMethod({
+    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/borrowIncentiveBuilder.ts
 var requireObligationInfo2 = async (...params) => {
   const [builder, txBlock, obligationId, obligationKey] = params;
   if (params.length === 4 && obligationId && obligationKey && typeof obligationId === "string") {
@@ -4313,59 +4820,115 @@ var requireObligationInfo2 = async (...params) => {
     obligationLocked: obligations[0].locked
   };
 };
+var getBindedObligationId = async (builder, veScaKey) => {
+  const borrowIncentivePkgId = builder.address.get("borrowIncentive.id");
+  const incentivePoolsId = builder.address.get(
+    "borrowIncentive.incentivePools"
+  );
+  const veScaPkgId = IS_VE_SCA_TEST ? "0xb220d034bdf335d77ae5bfbf6daf059c2cc7a1f719b12bfed75d1736fac038c8" : builder.address.get("vesca.id");
+  const client = builder.suiKit.client();
+  const incentivePoolsResponse = await client.getObject({
+    id: incentivePoolsId,
+    options: {
+      showContent: true
+    }
+  });
+  if (incentivePoolsResponse.data?.content?.dataType !== "moveObject")
+    return false;
+  const incentivePoolFields = incentivePoolsResponse.data.content.fields;
+  const veScaBindTableId = incentivePoolFields.ve_sca_bind.fields.id.id;
+  const keyType = `${borrowIncentivePkgId}::typed_id::TypedID<${veScaPkgId}::ve_sca::VeScaKey>`;
+  const veScaBindTableResponse = await client.getDynamicFieldObject({
+    parentId: veScaBindTableId,
+    name: {
+      type: keyType,
+      value: veScaKey
+    }
+  });
+  if (veScaBindTableResponse.data?.content?.dataType !== "moveObject")
+    return false;
+  const veScaBindTableFields = veScaBindTableResponse.data.content.fields;
+  const obligationId = veScaBindTableFields.value.fields.id;
+  return obligationId;
+};
 var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
   const borrowIncentiveIds = {
-    borrowIncentivePkg: builder.address.get("borrowIncentive.id"),
+    borrowIncentivePkg: IS_VE_SCA_TEST ? "0x4d5a7cefa4147b4ace0ca845b20437d6ac0d32e5f2f855171f745472c2576246" : builder.address.get("borrowIncentive.id"),
     query: builder.address.get("borrowIncentive.query"),
+    config: builder.address.get("borrowIncentive.config"),
     incentivePools: builder.address.get("borrowIncentive.incentivePools"),
     incentiveAccounts: builder.address.get(
       "borrowIncentive.incentiveAccounts"
     ),
     obligationAccessStore: builder.address.get("core.obligationAccessStore")
   };
+  const veScaIds = {
+    table: builder.address.get("vesca.table"),
+    treasury: builder.address.get("vesca.treasury"),
+    config: builder.address.get("vesca.config")
+  };
   return {
-    stakeObligation: (obligationId, obligaionKey) => {
-      const rewardCoinName = "sui";
-      const rewardType = builder.utils.parseCoinType(rewardCoinName);
+    stakeObligation: (obligationId, obligationKey) => {
       txBlock.moveCall(
         `${borrowIncentiveIds.borrowIncentivePkg}::user::stake`,
         [
+          borrowIncentiveIds.config,
           borrowIncentiveIds.incentivePools,
           borrowIncentiveIds.incentiveAccounts,
-          obligaionKey,
+          obligationKey,
           obligationId,
           borrowIncentiveIds.obligationAccessStore,
-          SUI_CLOCK_OBJECT_ID4
+          SUI_CLOCK_OBJECT_ID5
+        ]
+      );
+    },
+    stakeObligationWithVesca: (obligationId, obligationKey, veScaKey) => {
+      txBlock.moveCall(
+        `${borrowIncentiveIds.borrowIncentivePkg}::user::stake_with_ve_sca`,
+        [
+          borrowIncentiveIds.config,
+          borrowIncentiveIds.incentivePools,
+          borrowIncentiveIds.incentiveAccounts,
+          obligationKey,
+          obligationId,
+          borrowIncentiveIds.obligationAccessStore,
+          veScaIds.config,
+          veScaIds.treasury,
+          veScaIds.table,
+          veScaKey,
+          SUI_CLOCK_OBJECT_ID5
         ],
-        [rewardType]
+        []
       );
     },
-    unstakeObligation: (obligationId, obligaionKey) => {
-      const rewardCoinName = "sui";
-      const rewardType = builder.utils.parseCoinType(rewardCoinName);
+    unstakeObligation: (obligationId, obligationKey) => {
       txBlock.moveCall(
         `${borrowIncentiveIds.borrowIncentivePkg}::user::unstake`,
         [
+          borrowIncentiveIds.config,
           borrowIncentiveIds.incentivePools,
           borrowIncentiveIds.incentiveAccounts,
-          obligaionKey,
+          obligationKey,
           obligationId,
-          SUI_CLOCK_OBJECT_ID4
-        ],
-        [rewardType]
+          SUI_CLOCK_OBJECT_ID5
+        ]
       );
     },
-    claimBorrowIncentive: (obligationId, obligaionKey, coinName) => {
-      const rewardCoinName = borrowIncentiveRewardCoins[coinName];
+    claimBorrowIncentive: (obligationId, obligationKey, coinName, rewardCoinName) => {
+      const rewardCoinNames = borrowIncentiveRewardCoins[coinName];
+      if (rewardCoinNames.includes(rewardCoinName) === false) {
+        throw new Error(`Invalid reward coin name ${rewardCoinName}`);
+      }
       const rewardType = builder.utils.parseCoinType(rewardCoinName);
       return txBlock.moveCall(
         `${borrowIncentiveIds.borrowIncentivePkg}::user::redeem_rewards`,
         [
+          borrowIncentiveIds.config,
           borrowIncentiveIds.incentivePools,
           borrowIncentiveIds.incentiveAccounts,
-          obligaionKey,
+          obligationKey,
           obligationId,
-          SUI_CLOCK_OBJECT_ID4
+          SUI_CLOCK_OBJECT_ID5
         ],
         [rewardType]
       );
@@ -4386,12 +4949,51 @@ var generateBorrowIncentiveQuickMethod = ({ builder, txBlock }) => {
         obligationKey
       );
       const unstakeObligationBeforeStake = !!txBlock.txBlock.blockData.transactions.find(
-        (txn) => txn.kind === "MoveCall" && txn.target === `${builder.address.get("borrowIncentive.id")}::user::unstake`
+        (txn) => txn.kind === "MoveCall" && (txn.target === `${OLD_BORROW_INCENTIVE_PROTOCOL_ID}::user::unstake` || txn.target === (IS_VE_SCA_TEST ? `${"0x4d5a7cefa4147b4ace0ca845b20437d6ac0d32e5f2f855171f745472c2576246"}::user::unstake` : `${builder.address.get(
+          "borrowIncentive.id"
+        )}::user::unstake`))
       );
       if (!obligationLocked || unstakeObligationBeforeStake) {
         txBlock.stakeObligation(obligationArg, obligationtKeyArg);
       }
     },
+    stakeObligationWithVeScaQuick: async (obligation, obligationKey, veScaKey) => {
+      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 === `${OLD_BORROW_INCENTIVE_PROTOCOL_ID}::user::unstake` || txn.target === (IS_VE_SCA_TEST ? `${"0x4d5a7cefa4147b4ace0ca845b20437d6ac0d32e5f2f855171f745472c2576246"}::user::unstake` : `${builder.address.get(
+          "borrowIncentive.id"
+        )}::user::unstake`))
+      );
+      if (!obligationLocked || unstakeObligationBeforeStake) {
+        const veSca = await requireVeSca(builder, txBlock, veScaKey);
+        if (veSca) {
+          const bindedObligationId = await getBindedObligationId(
+            builder,
+            veSca.keyId
+          );
+          if (!bindedObligationId || bindedObligationId === obligationArg) {
+            txBlock.stakeObligationWithVesca(
+              obligationArg,
+              obligationtKeyArg,
+              veSca.keyId
+            );
+          } else {
+            txBlock.stakeObligation(obligationArg, obligationtKeyArg);
+          }
+        } else {
+          txBlock.stakeObligation(obligationArg, obligationtKeyArg);
+        }
+      }
+    },
     unstakeObligationQuick: async (obligation, obligationKey) => {
       const {
         obligationId: obligationArg,
@@ -4407,7 +5009,7 @@ var generateBorrowIncentiveQuickMethod = ({ builder, txBlock }) => {
         txBlock.unstakeObligation(obligationArg, obligationtKeyArg);
       }
     },
-    claimBorrowIncentiveQuick: async (coinName, obligation, obligationKey) => {
+    claimBorrowIncentiveQuick: async (coinName, rewardCoinName, obligation, obligationKey) => {
       const {
         obligationId: obligationArg,
         obligationKey: obligationtKeyArg
@@ -4420,13 +5022,14 @@ var generateBorrowIncentiveQuickMethod = ({ builder, txBlock }) => {
       return txBlock.claimBorrowIncentive(
         obligationArg,
         obligationtKeyArg,
-        coinName
+        coinName,
+        rewardCoinName
       );
     }
   };
 };
 var newBorrowIncentiveTxBlock = (builder, initTxBlock) => {
-  const txBlock = initTxBlock instanceof TransactionBlock3 ? new SuiKitTxBlock5(initTxBlock) : initTxBlock ? initTxBlock : new SuiKitTxBlock5();
+  const txBlock = initTxBlock instanceof TransactionBlock4 ? new SuiKitTxBlock6(initTxBlock) : initTxBlock ? initTxBlock : new SuiKitTxBlock6();
   const normalMethod = generateBorrowIncentiveNormalMethod({
     builder,
     txBlock
@@ -4455,15 +5058,18 @@ var newBorrowIncentiveTxBlock = (builder, initTxBlock) => {
 
 // src/builders/index.ts
 var newScallopTxBlock = (builder, initTxBlock) => {
+  const vescaTxBlock = newVeScaTxBlock(builder, initTxBlock);
   const borrowIncentiveTxBlock = newBorrowIncentiveTxBlock(
     builder,
-    initTxBlock
+    vescaTxBlock
   );
   const spoolTxBlock = newSpoolTxBlock(builder, borrowIncentiveTxBlock);
   const coreTxBlock = newCoreTxBlock(builder, spoolTxBlock);
   return new Proxy(coreTxBlock, {
     get: (target, prop) => {
-      if (prop in borrowIncentiveTxBlock) {
+      if (prop in vescaTxBlock) {
+        return Reflect.get(vescaTxBlock, prop);
+      } else if (prop in borrowIncentiveTxBlock) {
         return Reflect.get(borrowIncentiveTxBlock, prop);
       } else if (prop in spoolTxBlock) {
         return Reflect.get(spoolTxBlock, prop);
@@ -4963,7 +5569,7 @@ var ScallopClient = class {
     const coins = [];
     for (const stakeMarketCoin of stakeMarketCoins2) {
       const stakeCoinName = this.utils.parseCoinName(stakeMarketCoinName);
-      const coin = await txBlock.withdraw(stakeMarketCoin, stakeCoinName);
+      const coin = txBlock.withdraw(stakeMarketCoin, stakeCoinName);
       coins.push(coin);
     }
     txBlock.transferObjects(coins, sender);
@@ -4996,17 +5602,17 @@ var ScallopClient = class {
   /**
    * stake obligaion.
    *
-   * @param obligaionId - The obligation account object.
-   * @param obligaionKeyId - The obligation key account object.
+   * @param obligationId - The obligation account object.
+   * @param obligationKeyId - The obligation key account object.
    * @param sign - Decide to directly sign the transaction or return the transaction block.
    * @param walletAddress - The wallet address of the owner.
    * @return Transaction block response or transaction block
    */
-  async stakeObligation(obligaionId, obligaionKeyId, sign = true, walletAddress) {
+  async stakeObligation(obligationId, obligationKeyId, sign = true, walletAddress) {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
-    await txBlock.stakeObligationQuick(obligaionId, obligaionKeyId);
+    await txBlock.stakeObligationQuick(obligationId, obligationKeyId);
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock
@@ -5018,17 +5624,17 @@ var ScallopClient = class {
   /**
    * unstake obligaion.
    *
-   * @param obligaionId - The obligation account object.
-   * @param obligaionKeyId - The obligation key account object.
+   * @param obligationId - The obligation account object.
+   * @param obligationKeyId - The obligation key account object.
    * @param sign - Decide to directly sign the transaction or return the transaction block.
    * @param walletAddress - The wallet address of the owner.
    * @return Transaction block response or transaction block
    */
-  async unstakeObligation(obligaionId, obligaionKeyId, sign = true, walletAddress) {
+  async unstakeObligation(obligationId, obligationKeyId, sign = true, walletAddress) {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
-    await txBlock.unstakeObligationQuick(obligaionId, obligaionKeyId);
+    await txBlock.unstakeObligationQuick(obligationId, obligationKeyId);
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock
@@ -5047,16 +5653,21 @@ var ScallopClient = class {
    * @param walletAddress - The wallet address of the owner.
    * @return Transaction block response or transaction block
    */
-  async claimBorrowIncentive(coinName, obligaionId, obligaionKeyId, sign = true, walletAddress) {
+  async claimBorrowIncentive(coinName, obligationId, obligationKeyId, 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);
+    const rewardCoins = [];
+    for (const rewardCoinName of SUPPORT_BORROW_INCENTIVE_REWARDS) {
+      const rewardCoin = await txBlock.claimBorrowIncentiveQuick(
+        coinName,
+        rewardCoinName,
+        obligationId,
+        obligationKeyId
+      );
+      rewardCoins.push(rewardCoin);
+    }
+    txBlock.transferObjects(rewardCoins, sender);
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock
@@ -5178,7 +5789,14 @@ export {
   ADDRESSES_ID,
   API_BASE_URL,
   BORROW_FEE_PROTOCOL_ID,
+  IS_VE_SCA_TEST,
+  MAX_LOCK_DURATION,
+  MAX_LOCK_ROUNDS,
+  MIN_INITIAL_LOCK_AMOUNT,
+  MIN_TOP_UP_AMOUNT,
+  OLD_BORROW_INCENTIVE_PROTOCOL_ID,
   PROTOCOL_OBJECT_ID,
+  SCA_COIN_TYPE,
   SDK_API_BASE_URL,
   SUPPORT_BORROW_INCENTIVE_POOLS,
   SUPPORT_BORROW_INCENTIVE_REWARDS,
@@ -5195,6 +5813,7 @@ export {
   ScallopIndexer,
   ScallopQuery,
   ScallopUtils,
+  UNLOCK_ROUND_DURATION,
   assetCoins,
   borrowIncentiveRewardCoins,
   coinDecimals,