@scallop-io/sui-scallop-sdk 0.42.6 → 0.42.7

package/dist/index.js

@@ -691,12 +691,12 @@ var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
     parsedMarketPoolData.debtAmount
   );
   const borrowCoin = borrowAmount.shiftedBy(-1 * coinDecimal);
-  const teserveAmount = (0, import_bignumber.default)(parsedMarketPoolData.reserveAmount).plus(
+  const reserveAmount = (0, import_bignumber.default)(parsedMarketPoolData.reserveAmount).plus(
     increasedDebtAmount.multipliedBy(parsedMarketPoolData.reserveFactor)
   );
-  const reserveCoin = teserveAmount.shiftedBy(-1 * coinDecimal);
+  const reserveCoin = reserveAmount.shiftedBy(-1 * coinDecimal);
   const supplyAmount = (0, import_bignumber.default)(borrowAmount).plus(
-    Math.max(parsedMarketPoolData.cashAmount - teserveAmount.toNumber(), 0)
+    Math.max(parsedMarketPoolData.cashAmount - reserveAmount.toNumber(), 0)
   );
   const supplyCoin = supplyAmount.shiftedBy(-1 * coinDecimal);
   let utilizationRate = (0, import_bignumber.default)(borrowAmount).dividedBy(supplyAmount);
@@ -727,7 +727,7 @@ var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
     supplyCoin: supplyCoin.toNumber(),
     borrowAmount: borrowAmount.toNumber(),
     borrowCoin: borrowCoin.toNumber(),
-    reserveAmount: teserveAmount.toNumber(),
+    reserveAmount: reserveAmount.toNumber(),
     reserveCoin: reserveCoin.toNumber(),
     utilizationRate: utilizationRate.toNumber(),
     supplyApr: supplyApr.toNumber(),
@@ -1499,8 +1499,8 @@ var getSpool = async (query, stakeMarketCoinName, marketPool) => {
           rewardCoinDecimal
         );
         spool = {
-          marketCoin: stakeMarketCoinName,
-          symbol: query.utils.parseSymbol(stakeCoinName),
+          marketCoinName: stakeMarketCoinName,
+          symbol: query.utils.parseSymbol(stakeMarketCoinName),
           coinType: query.utils.parseCoinType(stakeCoinName),
           marketCoinType: query.utils.parseMarketCoinType(stakeCoinName),
           rewardCoinType: isMarketCoin(rewardCoin) ? query.utils.parseMarketCoinType(rewardCoin) : query.utils.parseCoinType(rewardCoin),
@@ -1875,13 +1875,13 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   coinAmounts = coinAmounts || await query.getCoinAmounts(assetCoinNames, ownerAddress);
   const collaterals = {};
   const debts = {};
-  let totalCollateralPools = 0;
-  let totalCollateralValue = (0, import_bignumber3.default)(0);
+  let totalDepositedPools = 0;
+  let totalDepositedValue = (0, import_bignumber3.default)(0);
   let totalBorrowCapacityValue = (0, import_bignumber3.default)(0);
   let totalRequiredCollateralValue = (0, import_bignumber3.default)(0);
-  let totalDebtPools = 0;
-  let totalDebtValue = (0, import_bignumber3.default)(0);
-  let totalDebtValueWithWeight = (0, import_bignumber3.default)(0);
+  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
@@ -1891,33 +1891,34 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
     const coinPrice = coinPrices?.[collateralCoinName];
     const coinAmount = coinAmounts?.[collateralCoinName] ?? 0;
     if (marketCollateral && coinPrice) {
-      const collateralAmount = (0, import_bignumber3.default)(collateral.amount);
-      const collateralCoin = collateralAmount.shiftedBy(-1 * coinDecimal);
-      const collateralValue = collateralCoin.multipliedBy(coinPrice);
-      const borrowCapacityValue = collateralValue.multipliedBy(
+      const depositedAmount = (0, import_bignumber3.default)(collateral.amount);
+      const depositedCoin = depositedAmount.shiftedBy(-1 * coinDecimal);
+      const depositedValue = depositedCoin.multipliedBy(coinPrice);
+      const borrowCapacityValue = depositedValue.multipliedBy(
         marketCollateral.collateralFactor
       );
-      const requiredCollateralValue2 = collateralValue.multipliedBy(
+      const requiredCollateralValue2 = depositedValue.multipliedBy(
         marketCollateral.liquidationFactor
       );
       const availableDepositAmount = (0, import_bignumber3.default)(coinAmount);
       const availableDepositCoin = availableDepositAmount.shiftedBy(
         -1 * coinDecimal
       );
-      totalCollateralValue = totalCollateralValue.plus(collateralValue);
+      totalDepositedValue = totalDepositedValue.plus(depositedValue);
       totalBorrowCapacityValue = totalBorrowCapacityValue.plus(borrowCapacityValue);
       totalRequiredCollateralValue = totalRequiredCollateralValue.plus(
         requiredCollateralValue2
       );
-      if (collateralAmount.isGreaterThan(0)) {
-        totalCollateralPools++;
+      if (depositedAmount.isGreaterThan(0)) {
+        totalDepositedPools++;
       }
       collaterals[collateralCoinName] = {
         coinName: collateralCoinName,
         coinType: collateral.type.name,
-        collateralAmount: collateralAmount.toNumber(),
-        collateralCoin: collateralCoin.toNumber(),
-        collateralValue: collateralValue.toNumber(),
+        symbol: query.utils.parseSymbol(collateralCoinName),
+        depositedAmount: depositedAmount.toNumber(),
+        depositedCoin: depositedCoin.toNumber(),
+        depositedValue: depositedValue.toNumber(),
         borrowCapacityValue: borrowCapacityValue.toNumber(),
         requiredCollateralValue: requiredCollateralValue2.toNumber(),
         availableDepositAmount: availableDepositAmount.toNumber(),
@@ -1936,28 +1937,33 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
     const coinPrice = coinPrices?.[poolCoinName];
     if (marketPool && coinPrice) {
       const increasedRate = marketPool.borrowIndex / Number(debt.borrowIndex) - 1;
-      const debtAmount = (0, import_bignumber3.default)(debt.amount);
-      const debtCoin = debtAmount.shiftedBy(-1 * coinDecimal);
-      const availableRepayAmount = debtAmount.multipliedBy(increasedRate + 1);
+      const borrowedAmount = (0, import_bignumber3.default)(debt.amount);
+      const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
+      const availableRepayAmount = borrowedAmount.multipliedBy(
+        increasedRate + 1
+      );
       const availableRepayCoin = availableRepayAmount.shiftedBy(
         -1 * coinDecimal
       );
-      const debtValue = availableRepayCoin.multipliedBy(coinPrice);
-      const debtValueWithWeight = debtValue.multipliedBy(
+      const borrowedValue = availableRepayCoin.multipliedBy(coinPrice);
+      const borrowedValueWithWeight = borrowedValue.multipliedBy(
         marketPool.borrowWeight
       );
-      totalDebtValue = totalDebtValue.plus(debtValue);
-      totalDebtValueWithWeight = totalDebtValueWithWeight.plus(debtValueWithWeight);
-      if (debtAmount.isGreaterThan(0)) {
-        totalDebtPools++;
+      totalBorrowedValue = totalBorrowedValue.plus(borrowedValue);
+      totalBorrowedValueWithWeight = totalBorrowedValueWithWeight.plus(
+        borrowedValueWithWeight
+      );
+      if (borrowedAmount.isGreaterThan(0)) {
+        totalBorrowedPools++;
       }
       debts[poolCoinName] = {
         coinName: poolCoinName,
         coinType: debt.type.name,
-        debtAmount: debtAmount.toNumber(),
-        debtCoin: debtCoin.toNumber(),
-        debtValue: debtValue.toNumber(),
-        debtValueWithWeight: debtValueWithWeight.toNumber(),
+        symbol: query.utils.parseSymbol(poolCoinName),
+        borrowedAmount: borrowedAmount.toNumber(),
+        borrowedCoin: borrowedCoin.toNumber(),
+        borrowedValue: borrowedValue.toNumber(),
+        borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
         borrowIndex: Number(debt.borrowIndex),
         availableBorrowAmount: 0,
         availableBorrowCoin: 0,
@@ -1966,33 +1972,33 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       };
     }
   }
-  let riskLevel = totalRequiredCollateralValue.isZero() && totalDebtValueWithWeight.isZero() ? (0, import_bignumber3.default)(0) : totalDebtValueWithWeight.dividedBy(totalRequiredCollateralValue);
+  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);
-  const accountBalanceValue = totalCollateralValue.minus(totalDebtValue).isGreaterThan(0) ? totalCollateralValue.minus(totalDebtValue) : (0, import_bignumber3.default)(0);
-  const availableCollateralValue = totalBorrowCapacityValue.minus(totalDebtValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalDebtValueWithWeight) : (0, import_bignumber3.default)(0);
-  const requiredCollateralValue = totalDebtValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : (0, import_bignumber3.default)(0);
-  const unhealthyCollateralValue = totalDebtValueWithWeight.minus(requiredCollateralValue).isGreaterThan(0) ? totalDebtValueWithWeight.minus(requiredCollateralValue) : (0, import_bignumber3.default)(0);
+  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);
+  const unhealthyCollateralValue = totalBorrowedValueWithWeight.minus(requiredCollateralValue).isGreaterThan(0) ? totalBorrowedValueWithWeight.minus(requiredCollateralValue) : (0, import_bignumber3.default)(0);
   const obligationAccount = {
     obligationId,
     // Deposited collateral value (collateral balance)
-    totalCollateralValue: totalCollateralValue.toNumber(),
+    totalDepositedValue: totalDepositedValue.toNumber(),
     // Borrowed debt value (liabilities balance)
-    totalDebtValue: totalDebtValue.toNumber(),
+    totalBorrowedValue: totalBorrowedValue.toNumber(),
     // The difference between the user’s actual deposit and loan (remaining balance)
     totalBalanceValue: accountBalanceValue.toNumber(),
     // Effective collateral value (the actual collateral value included in the calculation).
     totalBorrowCapacityValue: totalBorrowCapacityValue.toNumber(),
     // Available collateral value (the remaining collateral value that can be borrowed).
-    availableCollateralValue: availableCollateralValue.toNumber(),
+    totalAvailableCollateralValue: availableCollateralValue.toNumber(),
     // Available debt value (the actual borrowing value included in the calculation).
-    totalDebtValueWithWeight: totalDebtValueWithWeight.toNumber(),
+    totalBorrowedValueWithWeight: totalBorrowedValueWithWeight.toNumber(),
     // Required collateral value (avoid be liquidated).
-    requiredCollateralValue: requiredCollateralValue.toNumber(),
+    totalRequiredCollateralValue: requiredCollateralValue.toNumber(),
     // Unliquidated collateral value (pending liquidation).
-    unhealthyCollateralValue: unhealthyCollateralValue.toNumber(),
-    riskLevel: riskLevel.toNumber(),
-    totalCollateralPools,
-    totalDebtPools,
+    totalUnhealthyCollateralValue: unhealthyCollateralValue.toNumber(),
+    totalRiskLevel: riskLevel.toNumber(),
+    totalDepositedPools,
+    totalBorrowedPools,
     collaterals,
     debts
   };
@@ -2001,9 +2007,9 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   )) {
     const marketCollateral = market.collaterals[collateralCoinName];
     if (marketCollateral) {
-      const availableWithdrawAmount = obligationAccount.totalDebtValueWithWeight === 0 ? obligationCollateral.collateralAmount : Math.min(
-        (0, import_bignumber3.default)(obligationAccount.availableCollateralValue).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).multipliedBy(0.99).toNumber(),
-        obligationCollateral.collateralAmount,
+      const availableWithdrawAmount = obligationAccount.totalBorrowedValueWithWeight === 0 ? obligationCollateral.depositedAmount : Math.min(
+        (0, import_bignumber3.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).multipliedBy(0.99).toNumber(),
+        obligationCollateral.depositedAmount,
         marketCollateral.depositAmount
       );
       obligationCollateral.availableWithdrawAmount = availableWithdrawAmount;
@@ -2018,8 +2024,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       const availableRepayAmount = (0, import_bignumber3.default)(
         obligationDebt.availableRepayAmount
       ).multipliedBy(1.01).toNumber();
-      const availableBorrowAmount = obligationAccount.availableCollateralValue !== 0 ? Math.min(
-        (0, import_bignumber3.default)(obligationAccount.availableCollateralValue).dividedBy(
+      const availableBorrowAmount = obligationAccount.totalAvailableCollateralValue !== 0 ? Math.min(
+        (0, import_bignumber3.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(
           (0, import_bignumber3.default)(marketPool.coinPrice).multipliedBy(
             marketPool.borrowWeight
           )