@evaafi/sdk 0.5.5 → 0.5.6-a

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@evaafi/sdk",
-  "version": "0.5.5",
+  "version": "0.5.6a",
   "description": "SDK for EVAA contracts",
   "main": "dist/index.js",
-  "types": "src/index.ts",
   "files": [
     "dist",
     "src"
@@ -21,7 +20,7 @@
   "devDependencies": {
     "@orbs-network/ton-access": "^2.3.3",
     "@ton/core": "0.56.0",
-    "@tonconnect/sdk": "^3.0.0",
+    "@tonconnect/sdk": "^3.0.5",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.10.4",
     "crypto-js": "^4.2.0",

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;
@@ -12,8 +14,9 @@ export function mulDiv(x: bigint, y: bigint, z: bigint): bigint {
 }
 
 export function mulDivC(x: bigint, y: bigint, z: bigint): bigint {
-    const mul = x * y;
-    return mul / z + (mul % z ? 1n : 0n);
+    //const mul = x * y;
+    //return mul / z + (mul % z ? 1n : 0n);
+    return BigInt(Math.ceil(Number(x * y) / Number(z)));
 }
 
 export function bigIntMax(...args: bigint[]): bigint {
@@ -125,13 +128,115 @@ export function checkNotInDebtAtAll(principals: Dictionary<bigint, bigint>): boo
     return principals.values().every(x => x >= 0n);
 }
 
-export function calculateMaximumWithdrawAmount(
+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)!;
+        // console.log('price', price);
+        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;
+        }
+        // console.log('aggregated', assetId, presentValue(assetData.sRate, assetData.bRate, principal, masterConstants).type, 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
+    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, prices, masterConstants);
+            let maxAmountToReclaim = 
+                mulDiv(
+                    agregatedBalances.totalSupply - mulDivC(agregatedBalances.totalBorrow, masterConstants.ASSET_COEFFICIENT_SCALE, assetConfig.collateralFactor),
+                    10n**assetConfig.decimals,
+                    price
+                );
+          
+            withdrawAmountMax = bigIntMin(
+                maxAmountToReclaim,
+                oldPresentValue.amount
+            );
+            //console.log('agregatedBalances', agregatedBalances);
+            //console.log('masterConstants.ASSET_COEFFICIENT_SCALE', masterConstants.ASSET_COEFFICIENT_SCALE);
+            //console.log('assetConfig.collateralFactor', assetConfig.collateralFactor);
+            //console.log('sekay', 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;
 
@@ -152,6 +257,7 @@ export function calculateMaximumWithdrawAmount(
             const price = prices.get(assetId) as bigint;
 
             let maxAmountToReclaim = 0n;
+
             if (assetConfig.collateralFactor == 0n) {
                 maxAmountToReclaim = oldPresentValue.amount;
             }
@@ -230,74 +336,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,
@@ -308,10 +426,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,
@@ -319,7 +437,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)!;
@@ -337,13 +455,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,17 +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> {
@@ -203,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();
@@ -240,17 +245,23 @@ 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;
-        const balance = presentValue(assetData.sRate, assetData.bRate, principals, masterConstants);
 
-        if (applyDust && (principals > -assetConfig.dust && balance.amount < assetConfig.dust)) {  // v6 will be 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);
         }
         userBalances.set(asset.assetId, balance);
@@ -280,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;
-        const balance = presentValue(assetData.sRate, assetData.bRate, principals, masterConstants);
 
-        if (applyDust && (principals > -assetConfig.dust && balance.amount < assetConfig.dust )) {  // v6 will be 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);
         }
 
         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;
 
@@ -316,16 +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,
-                calculateMaximumWithdrawAmount(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants, asset.assetId)
-            );
+            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,
@@ -339,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/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,