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

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

@@ -109,7 +109,7 @@ export type CollateralStat = {
 };
 export type MarketPool = {
     coinName: SupportPoolCoins;
-    symbol: String;
+    symbol: string;
     coinType: string;
     marketCoinType: string;
     coinWrappedType: CoinWrappedType;

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

@@ -24,25 +24,25 @@ export type Lending = Required<Pick<MarketPool, 'coinName' | 'symbol' | 'coinTyp
     availableClaimAmount: number;
 };
 export type ObligationAccount = {
-    obligationId?: string;
-    obligationAccount?: ObligationAccount;
-    totalCollateralValue: number;
-    totalDebtValue: number;
+    obligationId: string;
+    totalDepositedValue: number;
+    totalBorrowedValue: number;
     totalBalanceValue: number;
     totalBorrowCapacityValue: number;
-    availableCollateralValue: number;
-    totalDebtValueWithWeight: number;
-    requiredCollateralValue: number;
-    unhealthyCollateralValue: number;
-    riskLevel: number;
-    totalCollateralPools: number;
-    totalDebtPools: number;
-    collaterals: OptionalKeys<Record<SupportPoolCoins, {
-        coinName: string;
+    totalAvailableCollateralValue: number;
+    totalBorrowedValueWithWeight: number;
+    totalRequiredCollateralValue: number;
+    totalUnhealthyCollateralValue: number;
+    totalRiskLevel: number;
+    totalDepositedPools: number;
+    totalBorrowedPools: number;
+    collaterals: OptionalKeys<Record<SupportCollateralCoins, {
+        coinName: SupportCollateralCoins;
         coinType: string;
-        collateralAmount: number;
-        collateralCoin: number;
-        collateralValue: number;
+        symbol: string;
+        depositedAmount: number;
+        depositedCoin: number;
+        depositedValue: number;
         borrowCapacityValue: number;
         requiredCollateralValue: number;
         availableDepositAmount: number;
@@ -50,13 +50,14 @@ export type ObligationAccount = {
         availableWithdrawAmount: number;
         availableWithdrawCoin: number;
     }>>;
-    debts: OptionalKeys<Record<SupportCollateralCoins, {
-        coinName: string;
+    debts: OptionalKeys<Record<SupportPoolCoins, {
+        coinName: SupportPoolCoins;
         coinType: string;
-        debtAmount: number;
-        debtCoin: number;
-        debtValue: number;
-        debtValueWithWeight: number;
+        symbol: string;
+        borrowedAmount: number;
+        borrowedCoin: number;
+        borrowedValue: number;
+        borrowedValueWithWeight: number;
         borrowIndex: number;
         availableBorrowAmount: number;
         availableBorrowCoin: number;

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

@@ -7,8 +7,8 @@ export type RewardPools = OptionalKeys<Record<SupportStakeMarketCoins, RewardPoo
 export type StakeAccounts = Record<SupportStakeMarketCoins, StakeAccount[]>;
 export type Spools = OptionalKeys<Record<SupportStakeMarketCoins, Spool>>;
 export type Spool = {
-    marketCoin: SupportStakeMarketCoins;
-    symbol: String;
+    marketCoinName: SupportStakeMarketCoins;
+    symbol: string;
     coinType: string;
     marketCoinType: string;
     rewardCoinType: string;

package/package.json

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

package/src/queries/portfolioQuery.ts

@@ -275,13 +275,13 @@ export const getObligationAccount = async (
 
   const collaterals: ObligationAccount['collaterals'] = {};
   const debts: ObligationAccount['debts'] = {};
-  let totalCollateralPools = 0;
-  let totalCollateralValue = BigNumber(0);
+  let totalDepositedPools = 0;
+  let totalDepositedValue = BigNumber(0);
   let totalBorrowCapacityValue = BigNumber(0);
   let totalRequiredCollateralValue = BigNumber(0);
-  let totalDebtPools = 0;
-  let totalDebtValue = BigNumber(0);
-  let totalDebtValueWithWeight = BigNumber(0);
+  let totalBorrowedPools = 0;
+  let totalBorrowedValue = BigNumber(0);
+  let totalBorrowedValueWithWeight = BigNumber(0);
 
   for (const collateral of obligationQuery.collaterals) {
     const collateralCoinName =
@@ -294,13 +294,13 @@ export const getObligationAccount = async (
     const coinAmount = coinAmounts?.[collateralCoinName] ?? 0;
 
     if (marketCollateral && coinPrice) {
-      const collateralAmount = BigNumber(collateral.amount);
-      const collateralCoin = collateralAmount.shiftedBy(-1 * coinDecimal);
-      const collateralValue = collateralCoin.multipliedBy(coinPrice);
-      const borrowCapacityValue = collateralValue.multipliedBy(
+      const depositedAmount = BigNumber(collateral.amount);
+      const depositedCoin = depositedAmount.shiftedBy(-1 * coinDecimal);
+      const depositedValue = depositedCoin.multipliedBy(coinPrice);
+      const borrowCapacityValue = depositedValue.multipliedBy(
         marketCollateral.collateralFactor
       );
-      const requiredCollateralValue = collateralValue.multipliedBy(
+      const requiredCollateralValue = depositedValue.multipliedBy(
         marketCollateral.liquidationFactor
       );
       const availableDepositAmount = BigNumber(coinAmount);
@@ -308,23 +308,24 @@ export const getObligationAccount = async (
         -1 * coinDecimal
       );
 
-      totalCollateralValue = totalCollateralValue.plus(collateralValue);
+      totalDepositedValue = totalDepositedValue.plus(depositedValue);
       totalBorrowCapacityValue =
         totalBorrowCapacityValue.plus(borrowCapacityValue);
       totalRequiredCollateralValue = totalRequiredCollateralValue.plus(
         requiredCollateralValue
       );
 
-      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: requiredCollateralValue.toNumber(),
         availableDepositAmount: availableDepositAmount.toNumber(),
@@ -346,32 +347,36 @@ export const getObligationAccount = async (
     if (marketPool && coinPrice) {
       const increasedRate =
         marketPool.borrowIndex / Number(debt.borrowIndex) - 1;
-      const debtAmount = BigNumber(debt.amount);
-      const debtCoin = debtAmount.shiftedBy(-1 * coinDecimal);
-      const availableRepayAmount = debtAmount.multipliedBy(increasedRate + 1);
+      const borrowedAmount = BigNumber(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);
+      totalBorrowedValue = totalBorrowedValue.plus(borrowedValue);
+      totalBorrowedValueWithWeight = totalBorrowedValueWithWeight.plus(
+        borrowedValueWithWeight
+      );
 
-      if (debtAmount.isGreaterThan(0)) {
-        totalDebtPools++;
+      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,
@@ -382,55 +387,56 @@ export const getObligationAccount = async (
   }
 
   let riskLevel =
-    totalRequiredCollateralValue.isZero() && totalDebtValueWithWeight.isZero()
+    totalRequiredCollateralValue.isZero() &&
+    totalBorrowedValueWithWeight.isZero()
       ? BigNumber(0)
-      : totalDebtValueWithWeight.dividedBy(totalRequiredCollateralValue);
+      : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
   riskLevel = riskLevel.isFinite()
     ? riskLevel.isLessThan(1)
       ? riskLevel
       : BigNumber(1)
     : BigNumber(1);
 
-  const accountBalanceValue = totalCollateralValue
-    .minus(totalDebtValue)
+  const accountBalanceValue = totalDepositedValue
+    .minus(totalBorrowedValue)
     .isGreaterThan(0)
-    ? totalCollateralValue.minus(totalDebtValue)
+    ? totalDepositedValue.minus(totalBorrowedValue)
     : BigNumber(0);
   const availableCollateralValue = totalBorrowCapacityValue
-    .minus(totalDebtValueWithWeight)
+    .minus(totalBorrowedValueWithWeight)
     .isGreaterThan(0)
-    ? totalBorrowCapacityValue.minus(totalDebtValueWithWeight)
+    ? totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight)
     : BigNumber(0);
-  const requiredCollateralValue = totalDebtValueWithWeight.isGreaterThan(0)
+  const requiredCollateralValue = totalBorrowedValueWithWeight.isGreaterThan(0)
     ? totalRequiredCollateralValue
     : BigNumber(0);
-  const unhealthyCollateralValue = totalDebtValueWithWeight
+  const unhealthyCollateralValue = totalBorrowedValueWithWeight
     .minus(requiredCollateralValue)
     .isGreaterThan(0)
-    ? totalDebtValueWithWeight.minus(requiredCollateralValue)
+    ? totalBorrowedValueWithWeight.minus(requiredCollateralValue)
     : BigNumber(0);
 
   const obligationAccount: ObligationAccount = {
     obligationId: 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,
   };
@@ -442,16 +448,16 @@ export const getObligationAccount = async (
       market.collaterals[collateralCoinName as SupportCollateralCoins];
     if (marketCollateral) {
       const availableWithdrawAmount =
-        obligationAccount.totalDebtValueWithWeight === 0
-          ? obligationCollateral.collateralAmount
+        obligationAccount.totalBorrowedValueWithWeight === 0
+          ? obligationCollateral.depositedAmount
           : Math.min(
-              BigNumber(obligationAccount.availableCollateralValue)
+              BigNumber(obligationAccount.totalAvailableCollateralValue)
                 .dividedBy(marketCollateral.collateralFactor)
                 .dividedBy(marketCollateral.coinPrice)
                 // Note: reduced chance of failure when calculations are inaccurate
                 .multipliedBy(0.99)
                 .toNumber(),
-              obligationCollateral.collateralAmount,
+              obligationCollateral.depositedAmount,
               marketCollateral.depositAmount
             );
       obligationCollateral.availableWithdrawAmount = availableWithdrawAmount;
@@ -471,9 +477,9 @@ export const getObligationAccount = async (
         .toNumber();
 
       const availableBorrowAmount =
-        obligationAccount.availableCollateralValue !== 0
+        obligationAccount.totalAvailableCollateralValue !== 0
           ? Math.min(
-              BigNumber(obligationAccount.availableCollateralValue)
+              BigNumber(obligationAccount.totalAvailableCollateralValue)
                 .dividedBy(
                   BigNumber(marketPool.coinPrice).multipliedBy(
                     marketPool.borrowWeight

package/src/queries/spoolQuery.ts

@@ -142,8 +142,8 @@ export const getSpool = async (
         );
 
         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)

package/src/types/query/core.ts

@@ -114,7 +114,7 @@ export type CollateralStat = { amount: string };
 
 export type MarketPool = {
   coinName: SupportPoolCoins;
-  symbol: String;
+  symbol: string;
   coinType: string;
   marketCoinType: string;
   coinWrappedType: CoinWrappedType;

package/src/types/query/portfolio.ts

@@ -40,28 +40,28 @@ export type Lending = Required<
 };
 
 export type ObligationAccount = {
-  obligationId?: string;
-  obligationAccount?: ObligationAccount;
-  totalCollateralValue: number;
-  totalDebtValue: number;
+  obligationId: string;
+  totalDepositedValue: number;
+  totalBorrowedValue: number;
   totalBalanceValue: number;
   totalBorrowCapacityValue: number;
-  availableCollateralValue: number;
-  totalDebtValueWithWeight: number;
-  requiredCollateralValue: number;
-  unhealthyCollateralValue: number;
-  riskLevel: number;
-  totalCollateralPools: number;
-  totalDebtPools: number;
+  totalAvailableCollateralValue: number;
+  totalBorrowedValueWithWeight: number;
+  totalRequiredCollateralValue: number;
+  totalUnhealthyCollateralValue: number;
+  totalRiskLevel: number;
+  totalDepositedPools: number;
+  totalBorrowedPools: number;
   collaterals: OptionalKeys<
     Record<
-      SupportPoolCoins,
+      SupportCollateralCoins,
       {
-        coinName: string;
+        coinName: SupportCollateralCoins;
         coinType: string;
-        collateralAmount: number;
-        collateralCoin: number;
-        collateralValue: number;
+        symbol: string;
+        depositedAmount: number;
+        depositedCoin: number;
+        depositedValue: number;
         borrowCapacityValue: number;
         requiredCollateralValue: number;
         availableDepositAmount: number;
@@ -73,14 +73,15 @@ export type ObligationAccount = {
   >;
   debts: OptionalKeys<
     Record<
-      SupportCollateralCoins,
+      SupportPoolCoins,
       {
-        coinName: string;
+        coinName: SupportPoolCoins;
         coinType: string;
-        debtAmount: number;
-        debtCoin: number;
-        debtValue: number;
-        debtValueWithWeight: number;
+        symbol: string;
+        borrowedAmount: number;
+        borrowedCoin: number;
+        borrowedValue: number;
+        borrowedValueWithWeight: number;
         borrowIndex: number;
         availableBorrowAmount: number;
         availableBorrowCoin: number;

package/src/types/query/spool.ts

@@ -14,8 +14,8 @@ export type StakeAccounts = Record<SupportStakeMarketCoins, StakeAccount[]>;
 export type Spools = OptionalKeys<Record<SupportStakeMarketCoins, Spool>>;
 
 export type Spool = {
-  marketCoin: SupportStakeMarketCoins;
-  symbol: String;
+  marketCoinName: SupportStakeMarketCoins;
+  symbol: string;
   coinType: string;
   marketCoinType: string;
   rewardCoinType: string;

package/src/utils/query.ts

@@ -101,12 +101,12 @@ export const calculateMarketPoolData = (
     parsedMarketPoolData.debtAmount
   );
   const borrowCoin = borrowAmount.shiftedBy(-1 * coinDecimal);
-  const teserveAmount = BigNumber(parsedMarketPoolData.reserveAmount).plus(
+  const reserveAmount = BigNumber(parsedMarketPoolData.reserveAmount).plus(
     increasedDebtAmount.multipliedBy(parsedMarketPoolData.reserveFactor)
   );
-  const reserveCoin = teserveAmount.shiftedBy(-1 * coinDecimal);
+  const reserveCoin = reserveAmount.shiftedBy(-1 * coinDecimal);
   const supplyAmount = BigNumber(borrowAmount).plus(
-    Math.max(parsedMarketPoolData.cashAmount - teserveAmount.toNumber(), 0)
+    Math.max(parsedMarketPoolData.cashAmount - reserveAmount.toNumber(), 0)
   );
   const supplyCoin = supplyAmount.shiftedBy(-1 * coinDecimal);
   let utilizationRate = BigNumber(borrowAmount).dividedBy(supplyAmount);
@@ -143,7 +143,7 @@ export const calculateMarketPoolData = (
     supplyCoin: supplyCoin.toNumber(),
     borrowAmount: borrowAmount.toNumber(),
     borrowCoin: borrowCoin.toNumber(),
-    reserveAmount: teserveAmount.toNumber(),
+    reserveAmount: reserveAmount.toNumber(),
     reserveCoin: reserveCoin.toNumber(),
     utilizationRate: utilizationRate.toNumber(),
     supplyApr: supplyApr.toNumber(),