@scallop-io/sui-scallop-sdk 0.44.5 → 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) => {
@@ -2373,16 +2384,19 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   let totalBorrowedPools = 0;
   let totalBorrowedValue = (0, import_bignumber3.default)(0);
   let totalBorrowedValueWithWeight = (0, import_bignumber3.default)(0);
-  for (const collateral of obligationQuery.collaterals) {
-    const collateralCoinName = query.utils.parseCoinNameFromType(
-      collateral.type.name
-    );
-    const coinDecimal = query.utils.getCoinDecimal(collateralCoinName);
-    const marketCollateral = market.collaterals[collateralCoinName];
-    const coinPrice = coinPrices?.[collateralCoinName];
-    const coinAmount = coinAmounts?.[collateralCoinName] ?? 0;
+  for (const assetCoinName of assetCoinNames) {
+    const collateral = obligationQuery.collaterals.find((collateral2) => {
+      const collateralCoinName = query.utils.parseCoinNameFromType(
+        collateral2.type.name
+      );
+      return assetCoinName === collateralCoinName;
+    });
+    const marketCollateral = market.collaterals[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
+    const coinPrice = coinPrices?.[assetCoinName];
+    const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
     if (marketCollateral && coinPrice) {
-      const depositedAmount = (0, import_bignumber3.default)(collateral.amount);
+      const depositedAmount = (0, import_bignumber3.default)(collateral?.amount ?? 0);
       const depositedCoin = depositedAmount.shiftedBy(-1 * coinDecimal);
       const depositedValue = depositedCoin.multipliedBy(coinPrice);
       const borrowCapacityValue = depositedValue.multipliedBy(
@@ -2403,10 +2417,10 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       if (depositedAmount.isGreaterThan(0)) {
         totalDepositedPools++;
       }
-      collaterals[collateralCoinName] = {
-        coinName: collateralCoinName,
-        coinType: collateral.type.name,
-        symbol: query.utils.parseSymbol(collateralCoinName),
+      collaterals[assetCoinName] = {
+        coinName: assetCoinName,
+        coinType: query.utils.parseCoinType(assetCoinName),
+        symbol: query.utils.parseSymbol(assetCoinName),
         coinDecimal,
         coinPrice,
         depositedAmount: depositedAmount.toNumber(),
@@ -2421,24 +2435,30 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       };
     }
   }
-  for (const debt of obligationQuery.debts) {
-    const poolCoinName = query.utils.parseCoinNameFromType(
-      debt.type.name
-    );
-    const coinDecimal = query.utils.getCoinDecimal(poolCoinName);
-    const marketPool = market.pools[poolCoinName];
-    const coinPrice = coinPrices?.[poolCoinName];
+  for (const assetCoinName of assetCoinNames) {
+    const debt = obligationQuery.debts.find((debt2) => {
+      const poolCoinName = query.utils.parseCoinNameFromType(
+        debt2.type.name
+      );
+      return assetCoinName === poolCoinName;
+    });
+    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 = marketPool.borrowIndex / Number(debt.borrowIndex) - 1;
-      const borrowedAmount = (0, import_bignumber3.default)(debt.amount);
+      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
       );
@@ -2449,17 +2469,19 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       if (borrowedAmount.isGreaterThan(0)) {
         totalBorrowedPools++;
       }
-      debts[poolCoinName] = {
-        coinName: poolCoinName,
-        coinType: debt.type.name,
-        symbol: query.utils.parseSymbol(poolCoinName),
+      debts[assetCoinName] = {
+        coinName: assetCoinName,
+        coinType: query.utils.parseCoinType(assetCoinName),
+        symbol: query.utils.parseSymbol(assetCoinName),
         coinDecimal,
         coinPrice,
         borrowedAmount: borrowedAmount.toNumber(),
         borrowedCoin: borrowedCoin.toNumber(),
         borrowedValue: borrowedValue.toNumber(),
         borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
-        borrowIndex: Number(debt.borrowIndex),
+        borrowIndex: Number(debt?.borrowIndex ?? 0),
+        requiredRepayAmount: requiredRepayAmount.toNumber(),
+        requiredRepayCoin: requiredRepayCoin.toNumber(),
         availableBorrowAmount: 0,
         availableBorrowCoin: 0,
         availableRepayAmount: availableRepayAmount.toNumber(),
@@ -2502,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);
@@ -2538,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(
@@ -2552,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;
@@ -2910,10 +2951,11 @@ var ScallopQuery = class {
    * borrowing and obligation information for specific pool.
    *
    * @param obligationId - The obligation id.
+   * @param ownerAddress - The owner address.
    * @return Borrowing and collateral information.
    */
-  async getObligationAccount(obligationId) {
-    return await getObligationAccount(this, obligationId);
+  async getObligationAccount(obligationId, ownerAddress) {
+    return await getObligationAccount(this, obligationId, ownerAddress);
   }
   /**
    * Get total value locked.
@@ -4407,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,
@@ -4414,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
@@ -4432,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