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

package/src/queries/portfolioQuery.ts

@@ -1,5 +1,6 @@
 import BigNumber from 'bignumber.js';
 import { SUPPORT_POOLS, SUPPORT_SPOOLS } from '../constants';
+import { minBigNumber } from 'src/utils';
 import type { ScallopQuery } from '../models';
 import type {
   Market,
@@ -133,7 +134,9 @@ export const getLending = async (
   let stakedCoin = BigNumber(0);
   let stakedValue = BigNumber(0);
   let availableUnstakeAmount = BigNumber(0);
+  let availableUnstakeCoin = BigNumber(0);
   let availableClaimAmount = BigNumber(0);
+  let availableClaimCoin = BigNumber(0);
 
   if (spool) {
     for (const stakeAccount of stakeAccounts) {
@@ -161,6 +164,7 @@ export const getLending = async (
       availableUnstakeAmount = availableUnstakeAmount.plus(
         accountStakedMarketCoinAmount
       );
+      availableUnstakeCoin = availableUnstakeAmount.shiftedBy(-1 * coinDecimal);
 
       const baseIndexRate = 1_000_000_000;
       const increasedPointRate = spool?.currentPointIndex
@@ -175,6 +179,7 @@ export const getLending = async (
           .multipliedBy(spool.exchangeRateNumerator)
           .dividedBy(spool.exchangeRateDenominator)
       );
+      availableClaimCoin = availableClaimAmount.shiftedBy(-1 * coinDecimal);
     }
   }
 
@@ -185,6 +190,20 @@ export const getLending = async (
   const suppliedCoin = suppliedAmount.shiftedBy(-1 * coinDecimal);
   const suppliedValue = suppliedCoin.multipliedBy(coinPrice ?? 0);
 
+  const unstakedMarketAmount = BigNumber(marketCoinAmount);
+  const unstakedMarketCoin = unstakedMarketAmount.shiftedBy(-1 * coinDecimal);
+
+  const availableSupplyAmount = BigNumber(coinAmount);
+  const availableSupplyCoin = availableSupplyAmount.shiftedBy(-1 * coinDecimal);
+  const availableWithdrawAmount = minBigNumber(
+    suppliedAmount,
+    marketPool?.supplyAmount ?? Infinity
+  ).plus(stakedAmount);
+  const availableWithdrawCoin = minBigNumber(
+    suppliedCoin,
+    marketPool?.supplyCoin ?? Infinity
+  ).plus(stakedCoin);
+
   const lending: Lending = {
     coinName: poolCoinName,
     symbol: query.utils.parseSymbol(poolCoinName),
@@ -194,7 +213,7 @@ export const getLending = async (
     coinPrice: coinPrice ?? 0,
     supplyApr: marketPool?.supplyApr ?? 0,
     supplyApy: marketPool?.supplyApy ?? 0,
-    rewardApr: spool?.stakeApr ?? 0,
+    rewardApr: spool?.rewardApr ?? 0,
     suppliedAmount: suppliedAmount.plus(stakedAmount).toNumber(),
     suppliedCoin: suppliedCoin.plus(stakedCoin).toNumber(),
     suppliedValue: suppliedValue.plus(stakedValue).toNumber(),
@@ -203,11 +222,21 @@ export const getLending = async (
     stakedAmount: stakedAmount.toNumber(),
     stakedCoin: stakedCoin.toNumber(),
     stakedValue: stakedValue.toNumber(),
-    availableSupplyAmount: coinAmount,
-    availableWithdrawAmount: 0,
-    availableStakeAmount: marketCoinAmount,
+    unstakedMarketAmount: unstakedMarketAmount.toNumber(),
+    unstakedMarketCoin: unstakedMarketCoin.toNumber(),
+    unstakedAmount: suppliedAmount.toNumber(),
+    unstakedCoin: suppliedCoin.toNumber(),
+    unstakedValue: suppliedValue.toNumber(),
+    availableSupplyAmount: availableSupplyAmount.toNumber(),
+    availableSupplyCoin: availableSupplyCoin.toNumber(),
+    availableWithdrawAmount: availableWithdrawAmount.toNumber(),
+    availableWithdrawCoin: availableWithdrawCoin.toNumber(),
+    availableStakeAmount: unstakedMarketAmount.toNumber(),
+    availableStakeCoin: unstakedMarketCoin.toNumber(),
     availableUnstakeAmount: availableUnstakeAmount.toNumber(),
+    availableUnstakeCoin: availableUnstakeCoin.toNumber(),
     availableClaimAmount: availableClaimAmount.toNumber(),
+    availableClaimCoin: availableClaimCoin.toNumber(),
   };
 
   return lending;
@@ -275,13 +304,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 +323,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 +337,26 @@ 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),
+        coinDecimal: coinDecimal,
+        coinPrice: coinPrice,
+        depositedAmount: depositedAmount.toNumber(),
+        depositedCoin: depositedCoin.toNumber(),
+        depositedValue: depositedValue.toNumber(),
         borrowCapacityValue: borrowCapacityValue.toNumber(),
         requiredCollateralValue: requiredCollateralValue.toNumber(),
         availableDepositAmount: availableDepositAmount.toNumber(),
@@ -346,32 +378,38 @@ 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),
+        coinDecimal: coinDecimal,
+        coinPrice: coinPrice,
+        borrowedAmount: borrowedAmount.toNumber(),
+        borrowedCoin: borrowedCoin.toNumber(),
+        borrowedValue: borrowedValue.toNumber(),
+        borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
         borrowIndex: Number(debt.borrowIndex),
         availableBorrowAmount: 0,
         availableBorrowCoin: 0,
@@ -382,55 +420,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,20 +481,23 @@ export const getObligationAccount = async (
       market.collaterals[collateralCoinName as SupportCollateralCoins];
     if (marketCollateral) {
       const availableWithdrawAmount =
-        obligationAccount.totalDebtValueWithWeight === 0
-          ? obligationCollateral.collateralAmount
-          : Math.min(
-              BigNumber(obligationAccount.availableCollateralValue)
+        obligationAccount.totalBorrowedValueWithWeight === 0
+          ? BigNumber(obligationCollateral.depositedAmount)
+          : minBigNumber(
+              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;
-      obligationCollateral.availableWithdrawCoin = availableWithdrawAmount;
+      obligationCollateral.availableWithdrawAmount =
+        availableWithdrawAmount.toNumber();
+      obligationCollateral.availableWithdrawCoin = availableWithdrawAmount
+        .shiftedBy(-1 * obligationCollateral.coinDecimal)
+        .toNumber();
     }
   }
   for (const [assetCoinName, obligationDebt] of Object.entries(
@@ -467,13 +509,12 @@ export const getObligationAccount = async (
         obligationDebt.availableRepayAmount
       )
         // Note: reduced chance of failure when calculations are inaccurate
-        .multipliedBy(1.01)
-        .toNumber();
+        .multipliedBy(1.01);
 
       const availableBorrowAmount =
-        obligationAccount.availableCollateralValue !== 0
-          ? Math.min(
-              BigNumber(obligationAccount.availableCollateralValue)
+        obligationAccount.totalAvailableCollateralValue !== 0
+          ? minBigNumber(
+              BigNumber(obligationAccount.totalAvailableCollateralValue)
                 .dividedBy(
                   BigNumber(marketPool.coinPrice).multipliedBy(
                     marketPool.borrowWeight
@@ -484,9 +525,15 @@ export const getObligationAccount = async (
                 .toNumber(),
               marketPool.supplyAmount
             )
-          : 0;
-      obligationDebt.availableBorrowAmount = availableBorrowAmount;
-      obligationDebt.availableRepayAmount = availableRepayAmount;
+          : BigNumber(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();
     }
   }
 

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/constant/enum.ts

@@ -25,3 +25,16 @@ export type StakeMarketCoins = {
 export type RewardCoins = {
   [key in SupportStakeMarketCoins]: SupportRewardCoins;
 };
+
+export type AssetCoinIds = {
+  [key in SupportAssetCoins]: string;
+};
+
+type PickFromUnion<T, K extends string> = K extends T ? K : never;
+
+export type WormholeCoinIds = {
+  [key in PickFromUnion<
+    SupportAssetCoins,
+    'eth' | 'btc' | 'usdc' | 'usdt' | 'apt' | 'sol'
+  >]: string;
+};

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;
@@ -123,6 +123,8 @@ export type MarketPool = {
 } & Required<
   Pick<
     ParsedMarketPoolData,
+    | 'highKink'
+    | 'midKink'
     | 'reserveFactor'
     | 'borrowWeight'
     | 'marketCoinSupplyAmount'

package/src/types/query/portfolio.ts

@@ -32,63 +32,74 @@ export type Lending = Required<
   stakedAmount: number;
   stakedCoin: number;
   stakedValue: number;
+  unstakedMarketAmount: number;
+  unstakedMarketCoin: number;
+  unstakedAmount: number;
+  unstakedCoin: number;
+  unstakedValue: number;
   availableSupplyAmount: number;
+  availableSupplyCoin: number;
   availableWithdrawAmount: number;
+  availableWithdrawCoin: number;
   availableStakeAmount: number;
+  availableStakeCoin: number;
   availableUnstakeAmount: number;
+  availableUnstakeCoin: number;
   availableClaimAmount: number;
+  availableClaimCoin: 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;
+  totalAvailableCollateralValue: number;
+  totalBorrowedValueWithWeight: number;
+  totalRequiredCollateralValue: number;
+  totalUnhealthyCollateralValue: number;
+  totalRiskLevel: number;
+  totalDepositedPools: number;
+  totalBorrowedPools: number;
   collaterals: OptionalKeys<
-    Record<
-      SupportPoolCoins,
-      {
-        coinName: string;
-        coinType: string;
-        collateralAmount: number;
-        collateralCoin: number;
-        collateralValue: number;
-        borrowCapacityValue: number;
-        requiredCollateralValue: number;
-        availableDepositAmount: number;
-        availableDepositCoin: number;
-        availableWithdrawAmount: number;
-        availableWithdrawCoin: number;
-      }
-    >
-  >;
-  debts: OptionalKeys<
-    Record<
-      SupportCollateralCoins,
-      {
-        coinName: string;
-        coinType: string;
-        debtAmount: number;
-        debtCoin: number;
-        debtValue: number;
-        debtValueWithWeight: number;
-        borrowIndex: number;
-        availableBorrowAmount: number;
-        availableBorrowCoin: number;
-        availableRepayAmount: number;
-        availableRepayCoin: number;
-      }
-    >
+    Record<SupportCollateralCoins, ObligationCollateral>
   >;
+  debts: OptionalKeys<Record<SupportPoolCoins, ObligationDebt>>;
+};
+
+export type ObligationCollateral = {
+  coinName: SupportCollateralCoins;
+  coinType: string;
+  symbol: string;
+  coinDecimal: number;
+  coinPrice: number;
+  depositedAmount: number;
+  depositedCoin: number;
+  depositedValue: number;
+  borrowCapacityValue: number;
+  requiredCollateralValue: number;
+  availableDepositAmount: number;
+  availableDepositCoin: number;
+  availableWithdrawAmount: number;
+  availableWithdrawCoin: number;
+};
+
+export type ObligationDebt = {
+  coinName: SupportPoolCoins;
+  coinType: string;
+  symbol: string;
+  coinDecimal: number;
+  coinPrice: number;
+  borrowedAmount: number;
+  borrowedCoin: number;
+  borrowedValue: number;
+  borrowedValueWithWeight: number;
+  borrowIndex: number;
+  availableBorrowAmount: number;
+  availableBorrowCoin: number;
+  availableRepayAmount: number;
+  availableRepayCoin: number;
 };
 
 export type TotalValueLocked = {

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;
@@ -82,7 +82,7 @@ export type ParsedRewardPoolData = {
 };
 
 export type CalculatedRewardPoolData = {
-  stakeApr: number;
+  rewardApr: number;
   totalRewardAmount: number;
   totalRewardCoin: number;
   totalRewardValue: number;

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(),
@@ -346,7 +346,7 @@ export const calculateRewardPoolData = (
     .shiftedBy(-1 * rewardCoinDecimal)
     .multipliedBy(rateYearFactor)
     .multipliedBy(rewardCoinPrice);
-  const stakeRate = rewardValueForYear
+  const rewardRate = rewardValueForYear
     .dividedBy(calculatedStakePoolData.stakedValue)
     .isFinite()
     ? rewardValueForYear
@@ -355,7 +355,7 @@ export const calculateRewardPoolData = (
     : Infinity;
 
   return {
-    stakeApr: stakeRate,
+    rewardApr: rewardRate,
     totalRewardAmount: totalRewardAmount.toNumber(),
     totalRewardCoin: totalRewardCoin.toNumber(),
     totalRewardValue: totalRewardValue.toNumber(),
@@ -370,3 +370,19 @@ export const calculateRewardPoolData = (
     exchangeRateDenominator: parsedRewardPoolData.exchangeRateDenominator,
   };
 };
+
+export const minBigNumber = (...args: BigNumber.Value[]) => {
+  return BigNumber(
+    args.reduce((min, current) =>
+      new BigNumber(current).lt(min) ? current : min
+    )
+  );
+};
+
+export const maxBigNumber = (...args: BigNumber.Value[]) => {
+  return BigNumber(
+    args.reduce((max, current) =>
+      new BigNumber(current).gt(max) ? current : max
+    )
+  );
+};