@scallop-io/sui-scallop-sdk 0.44.5 → 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;
     }>;
     /**
@@ -322,9 +324,10 @@ export declare class ScallopQuery {
      * borrowing and obligation information for specific pool.
      *
      * @param obligationId - The obligation id.
+     * @param ownerAddress - The owner address.
      * @return Borrowing and collateral information.
      */
-    getObligationAccount(obligationId: string): Promise<import("../types").ObligationAccount>;
+    getObligationAccount(obligationId: string, ownerAddress?: string): Promise<import("../types").ObligationAccount>;
     /**
      * Get total value locked.
      *

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.5",
+  "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/models/scallopQuery.ts

@@ -444,10 +444,14 @@ export class ScallopQuery {
    * borrowing and obligation information for specific pool.
    *
    * @param obligationId - The obligation id.
+   * @param ownerAddress - The owner address.
    * @return Borrowing and collateral information.
    */
-  public async getObligationAccount(obligationId: string) {
-    return await getObligationAccount(this, obligationId);
+  public async getObligationAccount(
+    obligationId: string,
+    ownerAddress?: string
+  ) {
+    return await getObligationAccount(this, obligationId, ownerAddress);
   }
 
   /**

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,
@@ -321,18 +321,22 @@ export const getObligationAccount = async (
   let totalBorrowedValue = BigNumber(0);
   let totalBorrowedValueWithWeight = BigNumber(0);
 
-  for (const collateral of obligationQuery.collaterals) {
-    const collateralCoinName =
-      query.utils.parseCoinNameFromType<SupportCollateralCoins>(
-        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((collateral) => {
+      const collateralCoinName =
+        query.utils.parseCoinNameFromType<SupportCollateralCoins>(
+          collateral.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 = BigNumber(collateral.amount);
+      const depositedAmount = BigNumber(collateral?.amount ?? 0);
       const depositedCoin = depositedAmount.shiftedBy(-1 * coinDecimal);
       const depositedValue = depositedCoin.multipliedBy(coinPrice);
       const borrowCapacityValue = depositedValue.multipliedBy(
@@ -357,10 +361,10 @@ export const getObligationAccount = async (
         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: coinDecimal,
         coinPrice: coinPrice,
         depositedAmount: depositedAmount.toNumber(),
@@ -376,26 +380,37 @@ export const getObligationAccount = async (
     }
   }
 
-  for (const debt of obligationQuery.debts) {
-    const poolCoinName = query.utils.parseCoinNameFromType<SupportPoolCoins>(
-      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((debt) => {
+      const poolCoinName = query.utils.parseCoinNameFromType<SupportPoolCoins>(
+        debt.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 = BigNumber(debt.amount);
+      const increasedRate = debt?.borrowIndex
+        ? marketPool.borrowIndex / Number(debt.borrowIndex) - 1
+        : 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
       );
@@ -409,17 +424,19 @@ export const getObligationAccount = async (
         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: coinDecimal,
         coinPrice: 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(),
@@ -472,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)
@@ -534,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(
@@ -559,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);
-
-      const availableBorrowAmount =
+        // 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')
+        );
+
+      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;
+};