@evaafi/sdk 0.5.4 → 0.5.6

package/src/api/math.ts

@@ -1,7 +1,9 @@
-import { AssetConfig, AssetData, AssetInterest, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants } from '../types/Master';
+import { AgregatedBalances, AssetConfig, AssetData, AssetInterest, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, PoolConfig } from '../types/Master';
 import { Dictionary } from '@ton/core';
 import { BalanceChangeType, BalanceType, LiquidationData, PredictHealthFactorArgs, UserBalance } from '../types/User';
 import { sha256Hash } from '../utils/sha256BigInt';
+import { TON_MAINNET, UNDEFINED_ASSET } from '../constants/assets';
+import { MAINNET_POOL_CONFIG, TESTNET_POOL_CONFIG } from '..';
 
 export function mulFactor(decimal: bigint, a: bigint, b: bigint): bigint {
     return (a * b) / decimal;
@@ -11,6 +13,11 @@ export function mulDiv(x: bigint, y: bigint, z: bigint): bigint {
     return (x * y) / z;
 }
 
+export function mulDivC(x: bigint, y: bigint, z: bigint): bigint {
+    const mul = x * y;
+    return mul / z + (mul % z ? 1n : 0n);
+}
+
 export function bigIntMax(...args: bigint[]): bigint {
     return args.reduce((m, e) => (e > m ? e : m));
 }
@@ -116,6 +123,165 @@ export function calculateAssetInterest(assetConfig: AssetConfig, assetData: Asse
     };
 }
 
+export function checkNotInDebtAtAll(principals: Dictionary<bigint, bigint>): boolean {
+    return principals.values().every(x => x >= 0n);
+}
+
+export function getAgregatedBalances (
+    assetsData: ExtendedAssetsData,
+    assetsConfig: ExtendedAssetsConfig,
+    principals: Dictionary<bigint, bigint>,
+    prices: Dictionary<bigint, bigint>,
+    masterConstants: MasterConstants,
+  ): AgregatedBalances {
+    let user_total_supply = 0n;
+    let user_total_borrow = 0n;
+  
+    for (const [assetId, principal] of principals) {
+
+        if (principal) {
+    
+        if (!prices.has(assetId)) {
+          return {totalSupply: 0n, totalBorrow: 0n};
+        }
+        const price = prices.get(assetId)!;
+        const assetData = assetsData.get(assetId)!;
+        const assetConfig = assetsConfig.get(assetId)!;
+  
+        if (principal < 0) {
+          user_total_borrow += presentValue(assetData.sRate, assetData.bRate, principal, masterConstants).amount * price / 10n ** assetConfig.decimals;
+        } else {
+          user_total_supply += presentValue(assetData.sRate, assetData.bRate, principal, masterConstants).amount * price / 10n ** assetConfig.decimals;
+        }
+  
+      }
+    }
+    return {totalSupply: user_total_supply, totalBorrow: user_total_borrow};
+  }
+
+/**
+ * @deprecated The method should be used only for main contract v5
+ */
+export function isV5MainPoolContract(poolConfig: PoolConfig): boolean {
+  if ((poolConfig.masterAddress == MAINNET_POOL_CONFIG.masterAddress && poolConfig.masterVersion == 5) || 
+  (poolConfig.masterAddress == TESTNET_POOL_CONFIG.masterAddress && poolConfig.masterVersion == 5)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * @deprecated The method should be used only for main contract v5
+ */
+export function calculateMaximumWithdrawAmountOld(
+    assetsConfig: ExtendedAssetsConfig,
+    assetsData: ExtendedAssetsData,
+    principals: Dictionary<bigint, bigint>,
+    prices: Dictionary<bigint, bigint>,
+    masterConstants: MasterConstants,
+    assetId: bigint,
+): bigint {
+    let withdrawAmountMax = 0n;
+
+    const assetConfig = assetsConfig.get(assetId) as AssetConfig;
+    const assetData = assetsData.get(assetId) as ExtendedAssetData;
+    const oldPrincipal = principals.get(assetId) as bigint;
+    const oldPresentValue = presentValue(assetData.sRate, assetData.bRate, oldPrincipal, masterConstants);
+
+    if (oldPresentValue.amount > assetConfig.dust) {
+        if(checkNotInDebtAtAll(principals)) {
+            withdrawAmountMax = oldPresentValue.amount; 
+        } else {
+            if (!prices.has(assetId)) {
+                return 0n;
+            }
+
+            //const borrowable = getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants);
+            const price = prices.get(assetId) as bigint;
+            const agregatedBalances = getAgregatedBalances(assetsData, assetsConfig, principals, principals, masterConstants);
+            let maxAmountToReclaim = 
+                mulDiv(
+                    agregatedBalances.totalSupply - mulDivC(agregatedBalances.totalBorrow, masterConstants.ASSET_COEFFICIENT_SCALE, assetConfig.collateralFactor),
+                    10n**assetConfig.decimals,
+                    price
+                );
+          
+            withdrawAmountMax = bigIntMin(
+                maxAmountToReclaim,
+                oldPresentValue.amount
+            );
+        }
+    } else {
+        if (!prices.has(assetId)) {
+            return 0n;
+        }
+
+        const price = prices.get(assetId) as bigint;
+
+        return getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants) * (10n ** assetConfig.decimals) / price;
+    }
+
+    return withdrawAmountMax;
+}
+
+export function calculateMaximumWithdrawAmount(  //  todo v6 ifelse dust not debt at all is fixed?
+    assetsConfig: ExtendedAssetsConfig,
+    assetsData: ExtendedAssetsData,
+    principals: Dictionary<bigint, bigint>,
+    prices: Dictionary<bigint, bigint>,
+    masterConstants: MasterConstants,
+    assetId: bigint,
+): bigint {
+    let withdrawAmountMax = 0n;
+
+    const assetConfig = assetsConfig.get(assetId) as AssetConfig;
+    const assetData = assetsData.get(assetId) as ExtendedAssetData;
+    const oldPrincipal = principals.get(assetId) as bigint;
+
+    if (oldPrincipal > assetConfig.dust) {
+        const oldPresentValue = presentValue(assetData.sRate, assetData.bRate, oldPrincipal, masterConstants);
+        if(checkNotInDebtAtAll(principals)) {
+            withdrawAmountMax = oldPresentValue.amount; 
+        } else {
+            if (!prices.has(assetId)) {
+                return 0n;
+            }
+
+            const borrowable = getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants);
+            const price = prices.get(assetId) as bigint;
+
+            let maxAmountToReclaim = 0n;
+
+            if (assetConfig.collateralFactor == 0n) {
+                maxAmountToReclaim = oldPresentValue.amount;
+            }
+            else if (price > 0) {
+                maxAmountToReclaim =
+                    mulDiv(
+                        mulDivC(borrowable, masterConstants.ASSET_COEFFICIENT_SCALE, assetConfig.collateralFactor),
+                        10n ** assetConfig.decimals, price
+                    );
+            }
+          
+            withdrawAmountMax = bigIntMin(
+                maxAmountToReclaim,
+                oldPresentValue.amount
+            );
+        }
+    } else {
+        if (!prices.has(assetId)) {
+            return 0n;
+        }
+
+        const price = prices.get(assetId) as bigint;
+
+        return getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants) * (10n ** assetConfig.decimals) / price;
+    }
+
+    return withdrawAmountMax;
+}
+
 export function getAvailableToBorrow(
     assetsConfig: ExtendedAssetsConfig,
     assetsData: ExtendedAssetsData,
@@ -136,9 +302,10 @@ export function getAvailableToBorrow(
             borrowAmount += (calculatePresentValue(assetData.bRate, -principal, masterConstants) * price) / 10n ** assetConfig.decimals;
         } else if (principal > 0) {
             borrowLimit +=
-                (calculatePresentValue(assetData.sRate, principal, masterConstants) * price * assetConfig.collateralFactor) /
-                10n ** assetConfig.decimals /
-                masterConstants.ASSET_COEFFICIENT_SCALE;
+            mulDivC(
+                mulDivC(calculatePresentValue(assetData.sRate, principal, masterConstants), price, 10n ** assetConfig.decimals),
+                assetConfig.collateralFactor,
+                masterConstants.ASSET_COEFFICIENT_SCALE);
         }
     }
 
@@ -164,74 +331,86 @@ export function presentValue(sRate: bigint, bRate: bigint, principalValue: bigin
     }
 }
 
+/**
+ * 
+ * @param assetsConfig 
+ * @param assetsData 
+ * @param principals 
+ * @param prices 
+ * @param poolConfig 
+ * @returns can return UNDEFINED_ASSET if there are no assets
+ */
 export function calculateLiquidationData(
     assetsConfig: ExtendedAssetsConfig,
     assetsData: ExtendedAssetsData,
     principals: Dictionary<bigint, bigint>,
     prices: Dictionary<bigint, bigint>,
-    masterConstants: MasterConstants,
+    poolConfig: PoolConfig,
 ): LiquidationData {
-    let gCollateralValue = 0n;
-    let gCollateralAsset = 0n;
-    let gLoanValue = 0n;
-    let gLoanAsset = 0n;
+    let collateralValue = 0n;
+    let collateralAsset = UNDEFINED_ASSET;
+    let loanValue = 0n;
+    let loanAsset = UNDEFINED_ASSET;
     let totalDebt = 0n;
     let totalLimit = 0n;
 
-    for (const key of principals.keys()) {
-        const principal = principals.get(key)!;
-        const assetConfig = assetsConfig.get(key)!;
-        const assetData = assetsData.get(key)!;
+    for (const asset of poolConfig.poolAssetsConfig) {
+        if (!principals.has(asset.assetId)) {
+            continue;
+        }
+        const principal = principals.get(asset.assetId)!;
+        const assetConfig = assetsConfig.get(asset.assetId)!;
+        const assetData = assetsData.get(asset.assetId)!;
         const balance =
             principal > 0 ? (principal * assetData.sRate) / BigInt(1e12) : (principal * assetData.bRate) / BigInt(1e12);
         if (balance > 0) {
-            const assetWorth = (balance * prices.get(key)!) / 10n ** assetConfig.decimals;
-            totalLimit += (assetWorth * assetConfig.liquidationThreshold) / masterConstants.ASSET_COEFFICIENT_SCALE;
-            if (assetWorth > gCollateralValue) {
-                gCollateralValue = assetWorth;
-                gCollateralAsset = key;
+            const assetWorth = (balance * prices.get(asset.assetId)!) / 10n ** assetConfig.decimals;
+            totalLimit += (assetWorth * assetConfig.liquidationThreshold) / poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE;
+            if (assetWorth > collateralValue) {
+                collateralValue = assetWorth;
+                collateralAsset = asset;
             }
         } else if (balance < 0) {
-            const assetWorth = (-balance * prices.get(key)!) / 10n ** assetConfig.decimals;
+            const assetWorth = (-balance * prices.get(asset.assetId)!) / 10n ** assetConfig.decimals;
             totalDebt += assetWorth;
-            if (assetWorth > gLoanValue) {
-                gLoanValue = assetWorth;
-                gLoanAsset = key;
+            if (assetWorth > loanValue) {
+                loanValue = assetWorth;
+                loanAsset = asset;
             }
         }
     }
 
-    if (totalLimit < totalDebt) {
-        const gLoanAssetPrice = prices.get(gLoanAsset)!;
+    if (collateralAsset.assetId !== UNDEFINED_ASSET.assetId && totalLimit < totalDebt) {
+        const loanAssetPrice = prices.get(loanAsset.assetId)!;
         const values: bigint[] = [];
-        const gCollateralAssetConfig = assetsConfig.get(gCollateralAsset)!;
-        const gLoanAssetConfig = assetsConfig.get(gLoanAsset)!;
-        const liquidationBonus = gCollateralAssetConfig.liquidationBonus;
-        const loanDecimal = 10n ** gLoanAssetConfig.decimals;
+        const collateralAssetConfig = assetsConfig.get(collateralAsset.assetId)!;
+        const loanAssetConfig = assetsConfig.get(loanAsset.assetId)!;
+        const liquidationBonus = collateralAssetConfig.liquidationBonus;
+        const loanScale = 10n ** loanAssetConfig.decimals;
         values.push(
-            (bigIntMax(gCollateralValue / 2n, bigIntMin(gCollateralValue, 10_000_000_000n)) *
-                loanDecimal *
-                masterConstants.ASSET_COEFFICIENT_SCALE) /
+            (bigIntMax(collateralValue / 2n, bigIntMin(collateralValue, 100_000_000_000n)) *
+                loanScale *
+                poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE) /
                 liquidationBonus /
-                gLoanAssetPrice,
+                loanAssetPrice,
         );
-        values.push((gLoanValue * loanDecimal) / gLoanAssetPrice);
+        values.push((loanValue * loanScale) / loanAssetPrice);
 
         const liquidationAmount = (bigIntMin(...values) as bigint) - 5n;
-        const gCollateralAssetPrice: bigint = prices.get(gCollateralAsset)!;
-        const collateralDecimal = 10n ** gCollateralAssetConfig.decimals;
+        const collateralAssetPrice: bigint = prices.get(collateralAsset.assetId)!;
+        const collateralDecimal = 10n ** collateralAssetConfig.decimals;
         let minCollateralAmount =
-            (((liquidationAmount * gLoanAssetPrice * liquidationBonus) / 10000n) * collateralDecimal) /
-                gCollateralAssetPrice /
-                loanDecimal -
+            (((liquidationAmount * loanAssetPrice * liquidationBonus) / poolConfig.masterConstants.ASSET_LIQUIDATION_BONUS_SCALE) * collateralDecimal) /
+                collateralAssetPrice /
+                loanScale -
             10n;
         minCollateralAmount = (minCollateralAmount * 97n) / 100n;
         if (minCollateralAmount / collateralDecimal >= 1n) {
             return {
-                greatestCollateralAsset: gCollateralAsset,
-                greatestCollateralValue: gCollateralValue,
-                greatestLoanAsset: gLoanAsset,
-                greatestLoanValue: gLoanValue,
+                greatestCollateralAsset: collateralAsset,
+                greatestCollateralValue: collateralValue,
+                greatestLoanAsset: loanAsset,
+                greatestLoanValue: loanValue,
                 totalDebt,
                 totalLimit,
                 liquidable: true,
@@ -242,10 +421,10 @@ export function calculateLiquidationData(
     }
 
     return {
-        greatestCollateralAsset: gCollateralAsset,
-        greatestCollateralValue: gCollateralValue,
-        greatestLoanAsset: gLoanAsset,
-        greatestLoanValue: gLoanValue,
+        greatestCollateralAsset: collateralAsset,
+        greatestCollateralValue: collateralValue,
+        greatestLoanAsset: loanAsset,
+        greatestLoanValue: loanValue,
         totalDebt,
         totalLimit,
         liquidable: false,
@@ -253,7 +432,7 @@ export function calculateLiquidationData(
 }
 
 export function predictHealthFactor(args: PredictHealthFactorArgs): number {
-    const liquidationData = calculateLiquidationData(args.assetsConfig, args.assetsData, args.balances, args.prices, args.masterConstants);
+    const liquidationData = calculateLiquidationData(args.assetsConfig, args.assetsData, args.principals, args.prices, args.poolConfig);
     const tokenHash = sha256Hash(args.tokenSymbol);
     
     const assetConfig = args.assetsConfig.get(tokenHash)!;
@@ -271,13 +450,13 @@ export function predictHealthFactor(args: PredictHealthFactorArgs): number {
 
     if (currentAmount != null && currentAmount != 0n) { 
         if (changeType == BalanceChangeType.Borrow) {
-            totalBorrow += currentBalance * (1 + Number(assetConfig.originationFee) / Number(args.masterConstants.ASSET_ORIGINATION_FEE_SCALE));
+            totalBorrow += currentBalance * (1 + Number(assetConfig.originationFee) / Number(args.poolConfig.masterConstants.ASSET_ORIGINATION_FEE_SCALE));
         } else if (changeType == BalanceChangeType.Repay) {
             totalBorrow -= currentBalance;
         } else if (changeType == BalanceChangeType.Withdraw) {
-            totalLimit -= currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.masterConstants.ASSET_COEFFICIENT_SCALE);
+            totalLimit -= currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE);
         } else if (changeType == BalanceChangeType.Supply) {
-            totalLimit += currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.masterConstants.ASSET_COEFFICIENT_SCALE);
+            totalLimit += currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE);
         }
     }
     if (Number(totalLimit) == 0) {

package/src/api/parser.ts

@@ -1,16 +1,21 @@
 import { beginCell, Cell, Dictionary, DictionaryValue, Slice } from '@ton/core';
-import { AssetConfig, AssetData, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants, MasterData, PoolAssetsConfig } from '../types/Master';
+import { AssetConfig, AssetData, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants, MasterData, PoolAssetsConfig, PoolConfig } from '../types/Master';
 import {
     bigIntMax,
     bigIntMin,
     calculateAssetData,
     calculateLiquidationData,
+    calculateMaximumWithdrawAmount,
+    calculateMaximumWithdrawAmountOld,
     calculatePresentValue,
     getAvailableToBorrow,
+    isV5MainPoolContract,
     presentValue,
 } from './math';
 import { loadMaybeMyRef, loadMyRef } from './helpers';
 import { BalanceType, UserBalance, UserData, UserLiteData, UserRewards } from '../types/User';
+import { MAINNET_POOL_CONFIG, TESTNET_POOL_CONFIG } from '../constants/pools';
+import { basename } from 'path';
 
 // Will be in v6
 /* export function createUserRewards(): DictionaryValue<UserRewards> {
@@ -202,11 +207,12 @@ export function parseUserLiteData(
     userDataBOC: string,
     assetsData: ExtendedAssetsData,
     assetsConfig: ExtendedAssetsConfig,
-    poolAssetsConfig: PoolAssetsConfig,
-    masterConstants: MasterConstants,
-    testnet: boolean = false,
-    applyDust: boolean = false
+    poolConfig: PoolConfig,
+    applyDust: boolean = true
 ): UserLiteData {
+    const poolAssetsConfig = poolConfig.poolAssetsConfig;
+    const masterConstants = poolConfig.masterConstants;
+
     const userSlice = Cell.fromBase64(userDataBOC).beginParse();
 
     const codeVersion = userSlice.loadCoins();
@@ -239,19 +245,25 @@ export function parseUserLiteData(
     }
     */
     userSlice.endParse();
-
+    const isV5Main = isV5MainPoolContract(poolConfig);
     const userBalances = Dictionary.empty<bigint, UserBalance>();
 
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
-        let principals = principalsDict.get(asset.assetId) || 0n;
 
-        if (applyDust && (principals > -assetConfig.dust && principals < assetConfig.dust)) {  // abs(principals) < dust
-            principals = 0n;
+        let principal = principalsDict.get(asset.assetId) || 0n;
+        let balance = presentValue(assetData.sRate, assetData.bRate, principal, masterConstants);
+        let leftBorder = isV5Main ? balance.amount : principal;
+
+        if (applyDust && (principal > 0 && (leftBorder < assetConfig.dust))) {  // v6 will be abs(principals) < dust
+            principal = 0n;
+            balance = {
+                amount: 0n,
+                type: BalanceType.supply,
+            };
             principalsDict.set(asset.assetId, 0n);
         }
-        const balance = presentValue(assetData.sRate, assetData.bRate, principals, masterConstants);
         userBalances.set(asset.assetId, balance);
     }
 
@@ -279,30 +291,36 @@ export function parseUserData(
     assetsData: ExtendedAssetsData,
     assetsConfig: ExtendedAssetsConfig,
     prices: Dictionary<bigint, bigint>,
-    poolAssetConfig: PoolAssetsConfig,
-    masterConstants: MasterConstants,
-    applyDust: boolean = false
+    poolConfig: PoolConfig,
+    applyDust: boolean = true
 ): UserData {
+    const poolAssetsConfig = poolConfig.poolAssetsConfig;
+    const masterConstants = poolConfig.masterConstants;
+
     const withdrawalLimits = Dictionary.empty<bigint, bigint>();
     const borrowLimits = Dictionary.empty<bigint, bigint>();
 
     let supplyBalance = 0n;
     let borrowBalance = 0n;
-    for (const [_, asset] of Object.entries(poolAssetConfig)) {
+    const isV5Main = isV5MainPoolContract(poolConfig);
+
+    for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
-        let principals = userLiteData.principals.get(asset.assetId) || 0n;
 
-        if (applyDust && (principals > -assetConfig.dust && principals < assetConfig.dust )) {  // abs(principals) < dust
-            principals = 0n;
+        let principal = userLiteData.principals.get(asset.assetId) || 0n;
+        const balance = presentValue(assetData.sRate, assetData.bRate, principal, masterConstants);
+        let leftBorder = isV5Main ? balance.amount : principal;
+
+        if (applyDust && (principal > 0 && (leftBorder < assetConfig.dust))) {  // v6 will be abs(principals) < dust
+            principal = 0n;
             userLiteData.principals.set(asset.assetId, 0n);
         }
 
-        const balance = presentValue(assetData.sRate, assetData.bRate, principals, masterConstants);
         userLiteData.balances.set(asset.assetId, balance);
     }
 
-    for (const [_, asset] of Object.entries(poolAssetConfig)) {
+    for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
         const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
 
@@ -315,27 +333,24 @@ export function parseUserData(
     }
 
     const availableToBorrow = getAvailableToBorrow(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants);
-    for (const [_, asset] of Object.entries(poolAssetConfig)) {
+    for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
         const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
         const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
-
+        
         if (balance.type === BalanceType.supply) {
-            withdrawalLimits.set(
-                asset.assetId,
-                bigIntMax(
-                    bigIntMin(
-                        assetData.balance,
-                        ((supplyBalance -
-                            (borrowBalance * masterConstants.ASSET_COEFFICIENT_SCALE) / assetConfig.collateralFactor) *
-                            10n ** assetConfig.decimals) /
-                            prices.get(asset.assetId)! -
-                            5n,
-                        balance.amount,
-                    ),
-                    0n,
-                ),
-            );
+            if (isV5MainPoolContract(poolConfig)) {
+                withdrawalLimits.set(
+                    asset.assetId,
+                    calculateMaximumWithdrawAmountOld(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants, asset.assetId)
+                );
+            }
+            else {
+                withdrawalLimits.set(
+                    asset.assetId,
+                    calculateMaximumWithdrawAmount(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants, asset.assetId)
+                );
+            }
         }
         borrowLimits.set(
             asset.assetId,
@@ -349,7 +364,7 @@ export function parseUserData(
             ? 0
             : Number(BigInt(1e9) - (availableToBorrow * BigInt(1e9)) / (borrowBalance + availableToBorrow)) / 1e7;
 
-    const liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants);
+    const liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.principals, prices, poolConfig);
     const healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
 
     return {

package/src/api/prices.ts

@@ -1,5 +1,6 @@
 import { beginCell, Cell, Dictionary } from '@ton/core';
 import { PriceData } from '../types/Common';
+import { MAIN_POOL_NFT_ID } from '../constants/general';
 
 type NftData = {
     ledgerIndex: number;
@@ -38,7 +39,7 @@ type OutputData = {
     };
 }
 
-export async function getPricesByNft(nftId: string, endpoints: string[] = ["api.stardust-mainnet.iotaledger.net"]) {
+export async function getPrices(endpoints: string[] = ["api.stardust-mainnet.iotaledger.net"], nftId: string = MAIN_POOL_NFT_ID) {
     return await Promise.any(endpoints.map(x => loadPrices(nftId, x)));
 }
 

package/src/constants/assets.ts

@@ -1,13 +1,21 @@
 import { Address, Cell } from "@ton/core";
 import { PoolAssetConfig } from "../types/Master";
 import { sha256Hash } from "../utils/sha256BigInt";
-import { JETTON_WALLET_STANDART_CODE, JETTON_WALLET_STANDART_CODE_TESTNET } from "./general";
+import { JETTON_WALLET_STANDART_CODE, JETTON_WALLET_STANDART_CODE_TESTNET, NULL_ADDRESS } from "./general";
+
+export const UNDEFINED_ASSET: PoolAssetConfig = { 
+    name: 'undefined_asset',
+    assetId: -1n,
+    jettonMasterAddress: NULL_ADDRESS,  // fake
+    jettonWalletCode: Cell.EMPTY 
+}
 
 export const TON_MAINNET: PoolAssetConfig = { 
     name: 'TON',
-    assetId: sha256Hash('TON') 
+    assetId: sha256Hash('TON'),
+    jettonMasterAddress: NULL_ADDRESS,  // fake
+    jettonWalletCode: Cell.EMPTY 
 }
-
 export const TON_TESTNET = TON_MAINNET;
 
 export const JUSDT_MAINNET: PoolAssetConfig = { 

package/src/constants/general.ts

@@ -7,15 +7,17 @@ export const MASTER_CONSTANTS = {
     ASSET_PRICE_SCALE: BigInt(1e9),
     ASSET_RESERVE_FACTOR_SCALE: 10000n,
     ASSET_LIQUIDATION_RESERVE_FACTOR_SCALE: 10000n,
-    ASSET_ORIGINATION_FEE_SCALE: BigInt(1e9)
+    ASSET_ORIGINATION_FEE_SCALE: BigInt(1e9),
+    ASSET_LIQUIDATION_THRESHOLD_SCALE: 10_000n,
+    ASSET_LIQUIDATION_BONUS_SCALE: 10_000n,
 };
 
+export const NULL_ADDRESS = Address.parse('UQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJKZ');
+
 export const EVAA_MASTER_MAINNET = Address.parse('EQC8rUZqR_pWV1BylWUlPNBzyiTYVoBEmQkMIQDZXICfnuRr');
 export const MAINNET_VERSION = 5;
-export const EVAA_MASTER_TESTNET = Address.parse('EQCoIxsE8m0Q_Ui9uM-2RPtVWXqHK0ttuW2Mccuaj4FfdkLl');
+export const EVAA_MASTER_TESTNET = Address.parse('EQCoIxsE8m0Q_Ui9uM-2RPtVWXqHK0ttuW2Mccuaj4FfdkLl');  // EQBghPVKxgauOyrcyNYNwE2MRRnebaNpDGpVDQLbml_LIXnK
 export const TESTNET_VERSION = 5;
-export const EVAA_LP_TESTNET = Address.parse('EQBghPVKxgauOyrcyNYNwE2MRRnebaNpDGpVDQLbml_LIXnK');
-export const EVAA_LP_TESTNET_VERSION = 5;
 export const EVAA_LP_MAINNET = Address.parse('EQBIlZX2URWkXCSg3QF2MJZU-wC5XkBoLww-hdWk2G37Jc6N');
 export const EVAA_LP_MAINNET_VERSION = 0;
 

package/src/constants/pools.ts

@@ -1,7 +1,7 @@
 import { Address } from "@ton/core";
 import { JUSDC_MAINNET, JUSDC_TESTNET, JUSDT_MAINNET, JUSDT_TESTNET, STTON_MAINNET, STTON_TESTNET, TON_MAINNET, TON_STORM_MAINNET, TONUSDT_DEDUST_MAINNET, TSTON_MAINNET, USDT_MAINNET, USDT_STORM_MAINNET } from "./assets";
 import { PoolConfig } from "../types/Master";
-import { EVAA_MASTER_MAINNET, EVAA_MASTER_TESTNET, LENDING_CODE, MAINNET_VERSION, MASTER_CONSTANTS, MAIN_POOL_NFT_ID, TESTNET_VERSION, LP_POOL_NFT_ID, EVAA_LP_TESTNET, EVAA_LP_TESTNET_VERSION, EVAA_LP_MAINNET, EVAA_LP_MAINNET_VERSION } from "./general";
+import { EVAA_MASTER_MAINNET, EVAA_MASTER_TESTNET, LENDING_CODE, MAINNET_VERSION, MASTER_CONSTANTS, MAIN_POOL_NFT_ID, TESTNET_VERSION, LP_POOL_NFT_ID, EVAA_LP_MAINNET, EVAA_LP_MAINNET_VERSION } from "./general";
 
 export const MAINNET_POOL_CONFIG: PoolConfig = {
     masterAddress: EVAA_MASTER_MAINNET,
@@ -33,20 +33,6 @@ export const TESTNET_POOL_CONFIG: PoolConfig = {
     lendingCode: LENDING_CODE
 };
 
-export const TESTNET_LP_POOL_CONFIG: PoolConfig = {
-    masterAddress: EVAA_LP_TESTNET,
-    masterVersion: EVAA_LP_TESTNET_VERSION,
-    masterConstants: MASTER_CONSTANTS,
-    nftId: LP_POOL_NFT_ID,
-    poolAssetsConfig: [
-        TON_MAINNET,
-        JUSDT_TESTNET,
-        JUSDC_TESTNET,
-        STTON_TESTNET
-    ],
-    lendingCode: LENDING_CODE
-};
-
 export const MAINNET_LP_POOL_CONFIG: PoolConfig = {
     masterAddress: EVAA_LP_MAINNET,
     masterVersion: EVAA_LP_MAINNET_VERSION,