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

package/dist/models/scallopClient.d.ts

@@ -192,7 +192,7 @@ export declare class ScallopClient {
      * @param walletAddress - The wallet address of the owner.
      * @return Transaction block response or transaction block.
      */
-    repay<S extends boolean>(poolCoinName: SupportPoolCoins, amount: number, sign: S | undefined, obligationId: string, walletAddress?: string): Promise<ScallopClientFnReturnType<S>>;
+    repay<S extends boolean>(poolCoinName: SupportPoolCoins, amount: number, sign: S | undefined, obligationId: string, obligationKey: string, walletAddress?: string): Promise<ScallopClientFnReturnType<S>>;
     /**
      * FlashLoan asset from the specific pool.
      *

package/dist/models/scallopQuery.d.ts

@@ -262,6 +262,7 @@ export declare class ScallopQuery {
      */
     getBorrowIncentivePools(coinNames?: SupportBorrowIncentiveCoins[]): Promise<{
         usdc?: import("../types").BorrowIncentivePool | undefined;
+        usdt?: import("../types").BorrowIncentivePool | undefined;
         sui?: import("../types").BorrowIncentivePool | undefined;
     }>;
     /**
@@ -273,6 +274,7 @@ export declare class ScallopQuery {
      */
     getBorrowIncentiveAccounts(obligationId: string, coinNames?: SupportBorrowIncentiveCoins[]): Promise<{
         usdc?: import("../types").ParsedBorrowIncentiveAccountData | undefined;
+        usdt?: import("../types").ParsedBorrowIncentiveAccountData | undefined;
         sui?: import("../types").ParsedBorrowIncentiveAccountData | undefined;
     }>;
     /**

package/dist/queries/borrowIncentiveQuery.d.ts

@@ -9,6 +9,7 @@ import type { SupportBorrowIncentiveCoins } from '../types';
  */
 export declare const queryBorrowIncentivePools: (query: ScallopQuery, borrowIncentiveCoinNames?: SupportBorrowIncentiveCoins[]) => Promise<{
     usdc?: import("../types").BorrowIncentivePool | undefined;
+    usdt?: import("../types").BorrowIncentivePool | undefined;
     sui?: import("../types").BorrowIncentivePool | undefined;
 }>;
 /**
@@ -20,5 +21,6 @@ export declare const queryBorrowIncentivePools: (query: ScallopQuery, borrowInce
  */
 export declare const queryBorrowIncentiveAccounts: (query: ScallopQuery, obligationId: string, borrowIncentiveCoinNames?: SupportBorrowIncentiveCoins[]) => Promise<{
     usdc?: import("../types").ParsedBorrowIncentiveAccountData | undefined;
+    usdt?: import("../types").ParsedBorrowIncentiveAccountData | undefined;
     sui?: import("../types").ParsedBorrowIncentiveAccountData | undefined;
 }>;

package/dist/types/query/portfolio.d.ts

@@ -77,6 +77,8 @@ export type ObligationDebt = {
     borrowedValue: number;
     borrowedValueWithWeight: number;
     borrowIndex: number;
+    requiredRepayAmount: number;
+    requiredRepayCoin: number;
     availableBorrowAmount: number;
     availableBorrowCoin: number;
     availableRepayAmount: number;

package/dist/utils/query.d.ts

@@ -58,3 +58,11 @@ export declare const calculateBorrowIncentiveRewardPoolData: (parsedBorrowIncent
 export declare const parseOriginBorrowIncentiveAccountData: (originBorrowIncentiveAccountData: OriginBorrowIncentiveAccountData) => ParsedBorrowIncentiveAccountData;
 export declare const minBigNumber: (...args: BigNumber.Value[]) => BigNumber;
 export declare const maxBigNumber: (...args: BigNumber.Value[]) => BigNumber;
+/**
+ * Dynamically adjust the decrease or increase ratio according to the amout
+ * @param amount - The amount required to calculate factor.
+ * @param scaleStep - The scale step required to determine the factor..
+ * @param type - The type of the calculation.
+ * @return The estimated factor
+ * */
+export declare const estimatedFactor: (amount: number, scaleStep: number, type: 'increase' | 'decrease') => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "0.44.6",
+  "version": "0.44.7",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",

package/src/constants/common.ts

@@ -40,7 +40,7 @@ export const SUPPORT_SPOOLS = ['ssui', 'susdc', 'susdt'] as const;
 
 export const SUPPORT_SPOOLS_REWARDS = ['sui'] as const;
 
-export const SUPPORT_BORROW_INCENTIVE_POOLS = ['sui', 'usdc'] as const;
+export const SUPPORT_BORROW_INCENTIVE_POOLS = ['sui', 'usdc', 'usdt'] as const;
 
 export const SUPPORT_BORROW_INCENTIVE_REWARDS = ['sui'] as const;
 export const SUPPORT_ORACLES = ['supra', 'switchboard', 'pyth'] as const;

package/src/constants/enum.ts

@@ -78,6 +78,7 @@ export const spoolRewardCoins: StakeRewardCoins = {
 export const borrowIncentiveRewardCoins: BorrowIncentiveRewardCoins = {
   sui: 'sui',
   usdc: 'sui',
+  usdt: 'sui',
 };
 
 export const coinIds: AssetCoinIds = {

package/src/models/scallopClient.ts

@@ -1,6 +1,6 @@
 import { normalizeSuiAddress } from '@mysten/sui.js/utils';
 import { SuiKit } from '@scallop-io/sui-kit';
-import { ADDRESSES_ID } from '../constants';
+import { ADDRESSES_ID, SUPPORT_BORROW_INCENTIVE_POOLS } from '../constants';
 import { ScallopAddress } from './scallopAddress';
 import { ScallopUtils } from './scallopUtils';
 import { ScallopBuilder } from './scallopBuilder';
@@ -481,6 +481,16 @@ export class ScallopClient {
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
 
+    const availableStake = (
+      SUPPORT_BORROW_INCENTIVE_POOLS as readonly SupportPoolCoins[]
+    ).includes(poolCoinName);
+    if (sign && availableStake) {
+      await txBlock.unstakeObligationQuick(
+        poolCoinName as SupportBorrowIncentiveCoins,
+        obligationId,
+        obligationKey
+      );
+    }
     const coin = await txBlock.borrowQuick(
       amount,
       poolCoinName,
@@ -488,6 +498,13 @@ export class ScallopClient {
       obligationKey
     );
     txBlock.transferObjects([coin], sender);
+    if (sign && availableStake) {
+      await txBlock.stakeObligationQuick(
+        poolCoinName as SupportBorrowIncentiveCoins,
+        obligationId,
+        obligationKey
+      );
+    }
 
     if (sign) {
       return (await this.suiKit.signAndSendTxn(
@@ -513,13 +530,31 @@ export class ScallopClient {
     amount: number,
     sign: S = true as S,
     obligationId: string,
+    obligationKey: string,
     walletAddress?: string
   ): Promise<ScallopClientFnReturnType<S>> {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
 
+    const availableStake = (
+      SUPPORT_BORROW_INCENTIVE_POOLS as readonly SupportPoolCoins[]
+    ).includes(poolCoinName);
+    if (sign && availableStake) {
+      await txBlock.unstakeObligationQuick(
+        poolCoinName as SupportBorrowIncentiveCoins,
+        obligationId,
+        obligationKey
+      );
+    }
     await txBlock.repayQuick(amount, poolCoinName, obligationId);
+    if (sign && availableStake) {
+      await txBlock.stakeObligationQuick(
+        poolCoinName as SupportBorrowIncentiveCoins,
+        obligationId,
+        obligationKey
+      );
+    }
 
     if (sign) {
       return (await this.suiKit.signAndSendTxn(

package/src/queries/portfolioQuery.ts

@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
 import { SUPPORT_POOLS, SUPPORT_SPOOLS } from '../constants';
-import { minBigNumber } from 'src/utils';
+import { minBigNumber, estimatedFactor } from 'src/utils';
 import type { ScallopQuery } from '../models';
 import type {
   Market,
@@ -330,8 +330,8 @@ export const getObligationAccount = async (
       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;
 
@@ -388,9 +388,10 @@ export const getObligationAccount = async (
       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
@@ -398,13 +399,18 @@ export const getObligationAccount = async (
         : 0;
       const borrowedAmount = BigNumber(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 = BigNumber(coinAmount);
       const availableRepayCoin = availableRepayAmount.shiftedBy(
         -1 * coinDecimal
       );
-      const borrowedValue = availableRepayCoin.multipliedBy(coinPrice);
+
+      const borrowedValue = requiredRepayCoin.multipliedBy(coinPrice);
       const borrowedValueWithWeight = borrowedValue.multipliedBy(
         marketPool.borrowWeight
       );
@@ -429,6 +435,8 @@ export const getObligationAccount = async (
         borrowedValue: borrowedValue.toNumber(),
         borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
         borrowIndex: Number(debt?.borrowIndex ?? 0),
+        requiredRepayAmount: requiredRepayAmount.toNumber(),
+        requiredRepayCoin: requiredRepayCoin.toNumber(),
         availableBorrowAmount: 0,
         availableBorrowCoin: 0,
         availableRepayAmount: availableRepayAmount.toNumber(),
@@ -481,16 +489,11 @@ export const getObligationAccount = async (
     }
   }
 
-  let riskLevel =
-    totalRequiredCollateralValue.isZero() &&
-    totalBorrowedValueWithWeight.isZero()
-      ? BigNumber(0)
-      : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
-  riskLevel = riskLevel.isFinite()
-    ? riskLevel.isLessThan(1)
-      ? riskLevel
-      : BigNumber(1)
-    : BigNumber(1);
+  let riskLevel = totalRequiredCollateralValue.isZero()
+    ? BigNumber(0)
+    : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
+  // Note: 100% represents the safety upper limit. Even if it exceeds 100% before it is liquidated, it will only display 100%.
+  riskLevel = riskLevel.isLessThan(1) ? riskLevel : BigNumber(1);
 
   const accountBalanceValue = totalDepositedValue
     .minus(totalBorrowedValue)
@@ -543,24 +546,38 @@ export const getObligationAccount = async (
     const marketCollateral =
       market.collaterals[collateralCoinName as SupportCollateralCoins];
     if (marketCollateral) {
-      const availableWithdrawAmount =
+      let estimatedAvailableWithdrawAmount = BigNumber(
+        obligationAccount.totalAvailableCollateralValue
+      )
+        .dividedBy(marketCollateral.collateralFactor)
+        .dividedBy(marketCollateral.coinPrice)
+        .shiftedBy(marketCollateral.coinDecimal);
+      estimatedAvailableWithdrawAmount =
         obligationAccount.totalBorrowedValueWithWeight === 0
-          ? BigNumber(obligationCollateral.depositedAmount)
+          ? // Note: when there is no debt record, there is no need to estimate and the deposited amount is directly used as available withdraw.
+            BigNumber(obligationCollateral.depositedAmount)
           : minBigNumber(
-              BigNumber(obligationAccount.totalAvailableCollateralValue)
-                .dividedBy(marketCollateral.collateralFactor)
-                .dividedBy(marketCollateral.coinPrice)
+              estimatedAvailableWithdrawAmount
                 // Note: reduced chance of failure when calculations are inaccurate
-                .multipliedBy(0.99)
+                .multipliedBy(
+                  estimatedFactor(
+                    BigNumber(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();
+        estimatedAvailableWithdrawAmount.toNumber();
+      obligationCollateral.availableWithdrawCoin =
+        estimatedAvailableWithdrawAmount
+          .shiftedBy(-1 * obligationCollateral.coinDecimal)
+          .toNumber();
     }
   }
   for (const [poolCoinName, obligationDebt] of Object.entries(
@@ -568,33 +585,49 @@ export const getObligationAccount = async (
   )) {
     const marketPool = market.pools[poolCoinName as SupportPoolCoins];
     if (marketPool) {
-      const availableRepayAmount = BigNumber(
-        obligationDebt.availableRepayAmount
+      const estimatedRequiredRepayAmount = BigNumber(
+        obligationDebt.requiredRepayAmount
       )
-        // Note: reduced chance of failure when calculations are inaccurate
-        .multipliedBy(1.01);
+        // Note: reduced chance of not being able to repay in full when calculations are inaccurate,
+        // and the contract will not actually take the excess amount.
+        .multipliedBy(
+          estimatedFactor(obligationDebt.borrowedValue, 3, 'decrease')
+        );
 
-      const availableBorrowAmount =
+      let estimatedAvailableBorrowAmount = BigNumber(
+        obligationAccount.totalAvailableCollateralValue
+      )
+        .dividedBy(marketPool.borrowWeight)
+        .shiftedBy(marketPool.coinDecimal)
+        .dividedBy(marketPool.coinPrice);
+      estimatedAvailableBorrowAmount =
         obligationAccount.totalAvailableCollateralValue !== 0
           ? minBigNumber(
-              BigNumber(obligationAccount.totalAvailableCollateralValue)
-                .dividedBy(
-                  BigNumber(marketPool.coinPrice).multipliedBy(
-                    marketPool.borrowWeight
+              estimatedAvailableBorrowAmount
+                // Note: reduced chance of failure when calculations are inaccurate
+                .multipliedBy(
+                  estimatedFactor(
+                    estimatedAvailableBorrowAmount
+                      .shiftedBy(-1 * marketPool.coinDecimal)
+                      .multipliedBy(marketPool.coinPrice)
+                      .toNumber(),
+                    3,
+                    'increase'
                   )
                 )
-                // Note: reduced chance of failure when calculations are inaccurate
-                .multipliedBy(0.99)
                 .toNumber(),
               marketPool.supplyAmount
             )
           : BigNumber(0);
-      obligationDebt.availableBorrowAmount = availableBorrowAmount.toNumber();
-      obligationDebt.availableBorrowCoin = availableBorrowAmount
+
+      obligationDebt.availableBorrowAmount =
+        estimatedAvailableBorrowAmount.toNumber();
+      obligationDebt.availableBorrowCoin = estimatedAvailableBorrowAmount
         .shiftedBy(-1 * obligationDebt.coinDecimal)
         .toNumber();
-      obligationDebt.availableRepayAmount = availableRepayAmount.toNumber();
-      obligationDebt.availableRepayCoin = availableRepayAmount
+      obligationDebt.requiredRepayAmount =
+        estimatedRequiredRepayAmount.toNumber();
+      obligationDebt.requiredRepayCoin = estimatedRequiredRepayAmount
         .shiftedBy(-1 * obligationDebt.coinDecimal)
         .toNumber();
     }

package/src/types/query/portfolio.ts

@@ -99,6 +99,8 @@ export type ObligationDebt = {
   borrowedValue: number;
   borrowedValueWithWeight: number;
   borrowIndex: number;
+  requiredRepayAmount: number;
+  requiredRepayCoin: number;
   availableBorrowAmount: number;
   availableBorrowCoin: number;
   availableRepayAmount: number;

package/src/utils/query.ts

@@ -612,3 +612,29 @@ export const maxBigNumber = (...args: BigNumber.Value[]) => {
     )
   );
 };
+
+/**
+ * Dynamically adjust the decrease or increase ratio according to the amout
+ * @param amount - The amount required to calculate factor.
+ * @param scaleStep - The scale step required to determine the factor..
+ * @param type - The type of the calculation.
+ * @return The estimated factor
+ * */
+export const estimatedFactor = (
+  amount: number,
+  scaleStep: number,
+  type: 'increase' | 'decrease'
+) => {
+  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;
+};