@scallop-io/sui-scallop-sdk 0.44.6 → 0.44.7

package/dist/constants/common.d.ts

@@ -6,7 +6,7 @@ export declare const SUPPORT_POOLS: readonly ["eth", "btc", "usdc", "usdt", "sui
 export declare const SUPPORT_COLLATERALS: readonly ["eth", "btc", "usdc", "usdt", "sui", "apt", "sol", "cetus", "afsui", "hasui", "vsui"];
 export declare const SUPPORT_SPOOLS: readonly ["ssui", "susdc", "susdt"];
 export declare const SUPPORT_SPOOLS_REWARDS: readonly ["sui"];
-export declare const SUPPORT_BORROW_INCENTIVE_POOLS: readonly ["sui", "usdc"];
+export declare const SUPPORT_BORROW_INCENTIVE_POOLS: readonly ["sui", "usdc", "usdt"];
 export declare const SUPPORT_BORROW_INCENTIVE_REWARDS: readonly ["sui"];
 export declare const SUPPORT_ORACLES: readonly ["supra", "switchboard", "pyth"];
 export declare const SUPPORT_PACKAGES: readonly ["coinDecimalsRegistry", "math", "whitelist", "x", "protocol", "protocolWhitelist", "query", "supra", "pyth", "switchboard", "xOracle", "testCoin"];

package/dist/index.js

@@ -93,7 +93,7 @@ var SUPPORT_COLLATERALS = [
 ];
 var SUPPORT_SPOOLS = ["ssui", "susdc", "susdt"];
 var SUPPORT_SPOOLS_REWARDS = ["sui"];
-var SUPPORT_BORROW_INCENTIVE_POOLS = ["sui", "usdc"];
+var SUPPORT_BORROW_INCENTIVE_POOLS = ["sui", "usdc", "usdt"];
 var SUPPORT_BORROW_INCENTIVE_REWARDS = ["sui"];
 var SUPPORT_ORACLES = ["supra", "switchboard", "pyth"];
 var SUPPORT_PACKAGES = [
@@ -174,7 +174,8 @@ var spoolRewardCoins = {
 };
 var borrowIncentiveRewardCoins = {
   sui: "sui",
-  usdc: "sui"
+  usdc: "sui",
+  usdt: "sui"
 };
 var coinIds = {
   sui: "0x0000000000000000000000000000000000000000000000000000000000000002",
@@ -1115,6 +1116,16 @@ var minBigNumber = (...args) => {
     )
   );
 };
+var estimatedFactor = (amount, scaleStep, type) => {
+  const amountOfDigits = Math.max(
+    1,
+    Math.floor(Math.log10(Math.abs(amount)) + 1)
+  );
+  const adjustScale = Math.max(Math.floor((amountOfDigits - 1) / scaleStep), 1) + 1;
+  let adjustFactor = Math.pow(10, -adjustScale);
+  adjustFactor = type === "increase" ? 1 - adjustFactor : 1 + adjustFactor;
+  return adjustFactor;
+};
 
 // src/utils/util.ts
 var isMarketCoin = (coinName) => {
@@ -2380,8 +2391,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       );
       return assetCoinName === collateralCoinName;
     });
-    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const marketCollateral = market.collaterals[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const coinPrice = coinPrices?.[assetCoinName];
     const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
     if (marketCollateral && coinPrice) {
@@ -2431,20 +2442,23 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       );
       return assetCoinName === poolCoinName;
     });
-    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const marketPool = market.pools[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const coinPrice = coinPrices?.[assetCoinName];
+    const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
     if (marketPool && coinPrice) {
       const increasedRate = debt?.borrowIndex ? marketPool.borrowIndex / Number(debt.borrowIndex) - 1 : 0;
       const borrowedAmount = (0, import_bignumber3.default)(debt?.amount ?? 0);
       const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
-      const availableRepayAmount = borrowedAmount.multipliedBy(
+      const requiredRepayAmount = borrowedAmount.multipliedBy(
         increasedRate + 1
       );
+      const requiredRepayCoin = requiredRepayAmount.shiftedBy(-1 * coinDecimal);
+      const availableRepayAmount = (0, import_bignumber3.default)(coinAmount);
       const availableRepayCoin = availableRepayAmount.shiftedBy(
         -1 * coinDecimal
       );
-      const borrowedValue = availableRepayCoin.multipliedBy(coinPrice);
+      const borrowedValue = requiredRepayCoin.multipliedBy(coinPrice);
       const borrowedValueWithWeight = borrowedValue.multipliedBy(
         marketPool.borrowWeight
       );
@@ -2466,6 +2480,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
         borrowedValue: borrowedValue.toNumber(),
         borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
         borrowIndex: Number(debt?.borrowIndex ?? 0),
+        requiredRepayAmount: requiredRepayAmount.toNumber(),
+        requiredRepayCoin: requiredRepayCoin.toNumber(),
         availableBorrowAmount: 0,
         availableBorrowCoin: 0,
         availableRepayAmount: availableRepayAmount.toNumber(),
@@ -2508,8 +2524,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       }
     }
   }
-  let riskLevel = totalRequiredCollateralValue.isZero() && totalBorrowedValueWithWeight.isZero() ? (0, import_bignumber3.default)(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
-  riskLevel = riskLevel.isFinite() ? riskLevel.isLessThan(1) ? riskLevel : (0, import_bignumber3.default)(1) : (0, import_bignumber3.default)(1);
+  let riskLevel = totalRequiredCollateralValue.isZero() ? (0, import_bignumber3.default)(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
+  riskLevel = riskLevel.isLessThan(1) ? riskLevel : (0, import_bignumber3.default)(1);
   const accountBalanceValue = totalDepositedValue.minus(totalBorrowedValue).isGreaterThan(0) ? totalDepositedValue.minus(totalBorrowedValue) : (0, import_bignumber3.default)(0);
   const availableCollateralValue = totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight) : (0, import_bignumber3.default)(0);
   const requiredCollateralValue = totalBorrowedValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : (0, import_bignumber3.default)(0);
@@ -2544,13 +2560,25 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   )) {
     const marketCollateral = market.collaterals[collateralCoinName];
     if (marketCollateral) {
-      const availableWithdrawAmount = obligationAccount.totalBorrowedValueWithWeight === 0 ? (0, import_bignumber3.default)(obligationCollateral.depositedAmount) : minBigNumber(
-        (0, import_bignumber3.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).multipliedBy(0.99).toNumber(),
+      let estimatedAvailableWithdrawAmount = (0, import_bignumber3.default)(
+        obligationAccount.totalAvailableCollateralValue
+      ).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).shiftedBy(marketCollateral.coinDecimal);
+      estimatedAvailableWithdrawAmount = obligationAccount.totalBorrowedValueWithWeight === 0 ? (
+        // Note: when there is no debt record, there is no need to estimate and the deposited amount is directly used as available withdraw.
+        (0, import_bignumber3.default)(obligationCollateral.depositedAmount)
+      ) : minBigNumber(
+        estimatedAvailableWithdrawAmount.multipliedBy(
+          estimatedFactor(
+            (0, import_bignumber3.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).toNumber(),
+            3,
+            "increase"
+          )
+        ).toNumber(),
         obligationCollateral.depositedAmount,
         marketCollateral.depositAmount
       );
-      obligationCollateral.availableWithdrawAmount = availableWithdrawAmount.toNumber();
-      obligationCollateral.availableWithdrawCoin = availableWithdrawAmount.shiftedBy(-1 * obligationCollateral.coinDecimal).toNumber();
+      obligationCollateral.availableWithdrawAmount = estimatedAvailableWithdrawAmount.toNumber();
+      obligationCollateral.availableWithdrawCoin = estimatedAvailableWithdrawAmount.shiftedBy(-1 * obligationCollateral.coinDecimal).toNumber();
     }
   }
   for (const [poolCoinName, obligationDebt] of Object.entries(
@@ -2558,21 +2586,28 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   )) {
     const marketPool = market.pools[poolCoinName];
     if (marketPool) {
-      const availableRepayAmount = (0, import_bignumber3.default)(
-        obligationDebt.availableRepayAmount
-      ).multipliedBy(1.01);
-      const availableBorrowAmount = obligationAccount.totalAvailableCollateralValue !== 0 ? minBigNumber(
-        (0, import_bignumber3.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(
-          (0, import_bignumber3.default)(marketPool.coinPrice).multipliedBy(
-            marketPool.borrowWeight
+      const estimatedRequiredRepayAmount = (0, import_bignumber3.default)(
+        obligationDebt.requiredRepayAmount
+      ).multipliedBy(
+        estimatedFactor(obligationDebt.borrowedValue, 3, "decrease")
+      );
+      let estimatedAvailableBorrowAmount = (0, import_bignumber3.default)(
+        obligationAccount.totalAvailableCollateralValue
+      ).dividedBy(marketPool.borrowWeight).shiftedBy(marketPool.coinDecimal).dividedBy(marketPool.coinPrice);
+      estimatedAvailableBorrowAmount = obligationAccount.totalAvailableCollateralValue !== 0 ? minBigNumber(
+        estimatedAvailableBorrowAmount.multipliedBy(
+          estimatedFactor(
+            estimatedAvailableBorrowAmount.shiftedBy(-1 * marketPool.coinDecimal).multipliedBy(marketPool.coinPrice).toNumber(),
+            3,
+            "increase"
           )
-        ).multipliedBy(0.99).toNumber(),
+        ).toNumber(),
         marketPool.supplyAmount
       ) : (0, import_bignumber3.default)(0);
-      obligationDebt.availableBorrowAmount = availableBorrowAmount.toNumber();
-      obligationDebt.availableBorrowCoin = availableBorrowAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
-      obligationDebt.availableRepayAmount = availableRepayAmount.toNumber();
-      obligationDebt.availableRepayCoin = availableRepayAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
+      obligationDebt.availableBorrowAmount = estimatedAvailableBorrowAmount.toNumber();
+      obligationDebt.availableBorrowCoin = estimatedAvailableBorrowAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
+      obligationDebt.requiredRepayAmount = estimatedRequiredRepayAmount.toNumber();
+      obligationDebt.requiredRepayCoin = estimatedRequiredRepayAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
     }
   }
   return obligationAccount;
@@ -4414,6 +4449,14 @@ var ScallopClient = class {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
+    const availableStake = SUPPORT_BORROW_INCENTIVE_POOLS.includes(poolCoinName);
+    if (sign && availableStake) {
+      await txBlock.unstakeObligationQuick(
+        poolCoinName,
+        obligationId,
+        obligationKey
+      );
+    }
     const coin = await txBlock.borrowQuick(
       amount,
       poolCoinName,
@@ -4421,6 +4464,13 @@ var ScallopClient = class {
       obligationKey
     );
     txBlock.transferObjects([coin], sender);
+    if (sign && availableStake) {
+      await txBlock.stakeObligationQuick(
+        poolCoinName,
+        obligationId,
+        obligationKey
+      );
+    }
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock
@@ -4439,11 +4489,26 @@ var ScallopClient = class {
    * @param walletAddress - The wallet address of the owner.
    * @return Transaction block response or transaction block.
    */
-  async repay(poolCoinName, amount, sign = true, obligationId, walletAddress) {
+  async repay(poolCoinName, amount, sign = true, obligationId, obligationKey, walletAddress) {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
+    const availableStake = SUPPORT_BORROW_INCENTIVE_POOLS.includes(poolCoinName);
+    if (sign && availableStake) {
+      await txBlock.unstakeObligationQuick(
+        poolCoinName,
+        obligationId,
+        obligationKey
+      );
+    }
     await txBlock.repayQuick(amount, poolCoinName, obligationId);
+    if (sign && availableStake) {
+      await txBlock.stakeObligationQuick(
+        poolCoinName,
+        obligationId,
+        obligationKey
+      );
+    }
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock