@evaafi/sdk 0.5.5 → 0.5.6

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,

package/src/contracts/MasterContract.ts

@@ -16,10 +16,10 @@ import {
 import { Maybe } from '@ton/core/dist/utils/maybe';
 import { EvaaUser } from './UserContract';
 import { parseMasterData } from '../api/parser';
-import { MasterData, PoolAssetConfig, PoolConfig, PoolJettonAssetConfig, PoolTonAssetConfig } from '../types/Master';
+import { MasterData, PoolAssetConfig, PoolConfig} from '../types/Master';
 import { JettonWallet } from './JettonWallet';
 import { getUserJettonWallet } from '../utils/userJettonWallet';
-import { getPrices, MAINNET_POOL_CONFIG } from '..';
+import { getPrices, isTonAsset, MAINNET_POOL_CONFIG } from '..';
 
 /**
  * Parameters for the Evaa contract
@@ -31,51 +31,26 @@ export type EvaaParameters = {
     debug?: boolean;
 };
 
-/**
- * Parameters for the Jetton message
- * @property responseAddress - address to send excesses
- * @property forwardAmount - amount to forward to the destination address
- */
-export type JettonMessageParameters = {
-    responseAddress?: Address;
-    forwardAmount?: bigint;
-};
-
 /**
  * Base parameters for supply
  * @property queryID - unique query ID
  * @property includeUserCode - true to include user code for update (needed when user contract code version is outdated)
  * @property amount - amount to supply
  * @property userAddress - user address
- * @property assetID - asset ID
+ * @property asset
  */
-export type SupplyBaseParameters = {
+export type SupplyParameters = {
+    asset: PoolAssetConfig
     queryID: bigint;
     includeUserCode: boolean;
     amount: bigint;
     userAddress: Address;
+    responseAddress?: Address;
+    forwardAmount?: bigint;
     /* Will be in v6 
     amountToTransfer: bigint;
     payload: Cell; */
-};
-/**
- * Parameters for the TON supply message
- * @property type - 'ton'
- */
-export type TonSupplyParameters = SupplyBaseParameters & {
-    asset: PoolAssetConfig;
-};
-/**
- * Parameters for the jetton supply message
- * @property type - 'jetton'
- */
-export type JettonSupplyParameters = SupplyBaseParameters &
-    JettonMessageParameters & {
-        asset: PoolJettonAssetConfig & PoolAssetConfig;
-    };
-
-export type SupplyParameters = TonSupplyParameters | JettonSupplyParameters;
-
+}
 
 /**
  * Parameters for the withdraw message
@@ -124,29 +99,16 @@ export type LiquidationBaseData = {
  * @property includeUserCode - true to include user code for update (needed when user contract code version is outdated)
  * @property priceData - price data cell. Can be obtained from the getPrices function
  */
-export type LiquidationBaseParameters = LiquidationBaseData & {
+export type LiquidationParameters = LiquidationBaseData & {
+    asset: PoolAssetConfig;
     queryID: bigint;
     liquidatorAddress: Address;
     includeUserCode: boolean;
     priceData: Cell;
+    responseAddress?: Address;
+    forwardAmount?: bigint;
 };
 
-/**
- * Parameters for the TON liquidation message
- * @property type - 'ton'
- */
-export type TonLiquidationParameters = LiquidationBaseParameters & {
-    asset: PoolAssetConfig;
-};
-/**
- * Parameters for the jetton liquidation message
- * @property type - 'jetton'
- */
-export type JettonLiquidationParameters = LiquidationBaseParameters &
-    JettonMessageParameters & {
-        asset: PoolAssetConfig & PoolJettonAssetConfig
-    };
-
 /**
  * Evaa master contract wrapper
  */
@@ -172,17 +134,15 @@ export class Evaa implements Contract {
      * @returns supply message as a cell
      */
     createSupplyMessage(parameters: SupplyParameters): Cell {
-        if ('jettonMasterAddress' in parameters.asset) {
-            const jettonParams = parameters as JettonSupplyParameters;
-
+        if (!isTonAsset(parameters.asset)) {
             return beginCell()
                 .storeUint(OPCODES.JETTON_TRANSFER, 32)
                 .storeUint(parameters.queryID, 64)
                 .storeCoins(parameters.amount)
                 .storeAddress(this.address)
-                .storeAddress(jettonParams.responseAddress ?? parameters.userAddress)
+                .storeAddress(parameters.responseAddress ?? parameters.userAddress)
                 .storeBit(0)
-                .storeCoins(jettonParams.forwardAmount ?? FEES.SUPPLY_JETTON_FWD)
+                .storeCoins(parameters.forwardAmount ?? FEES.SUPPLY_JETTON_FWD)
                 .storeBit(1)
                 .storeRef(
                     beginCell()
@@ -232,18 +192,16 @@ export class Evaa implements Contract {
      * Create liquidation message
      * @returns liquidation message as a cell
      */
-    createLiquidationMessage(parameters: TonLiquidationParameters | JettonLiquidationParameters): Cell {
-        if ('jettonMasterAddress' in parameters.asset) {
-            const jettonParams = parameters as JettonLiquidationParameters;
-
+    createLiquidationMessage(parameters: LiquidationParameters): Cell {
+        if (!isTonAsset(parameters.asset)) {
             return beginCell()
                 .storeUint(OPCODES.JETTON_TRANSFER, 32)
                 .storeUint(parameters.queryID, 64)
                 .storeCoins(parameters.liquidationAmount)
                 .storeAddress(this.address)
-                .storeAddress(jettonParams.responseAddress ?? parameters.liquidatorAddress)
+                .storeAddress(parameters.responseAddress ?? parameters.liquidatorAddress)
                 .storeBit(0)
-                .storeCoins(jettonParams.forwardAmount ?? FEES.LIQUIDATION_JETTON_FWD)
+                .storeCoins(parameters.forwardAmount ?? FEES.LIQUIDATION_JETTON_FWD)
                 .storeBit(1)
                 .storeRef(
                     beginCell()
@@ -323,11 +281,11 @@ export class Evaa implements Contract {
         provider: ContractProvider,
         via: Sender,
         value: bigint,
-        parameters: TonSupplyParameters | JettonSupplyParameters,
+        parameters: SupplyParameters,
     ) {
         const message = this.createSupplyMessage(parameters);
 
-        if ('jettonMasterAddress' in parameters.asset) {
+        if (!isTonAsset(parameters.asset)) {
             if (!via.address) {
                 throw Error('Via address is required for jetton supply');
             }
@@ -360,11 +318,11 @@ export class Evaa implements Contract {
         provider: ContractProvider,
         via: Sender,
         value: bigint,
-        parameters: TonLiquidationParameters | JettonLiquidationParameters,
+        parameters: LiquidationParameters,
     ) {
         const message = this.createLiquidationMessage(parameters);
 
-        if ('jettonMasterAddress' in parameters.asset) {
+        if (!isTonAsset(parameters.asset)) {
             if (!via.address) {
                 throw Error('Via address is required for jetton liquidation');
             }

package/src/contracts/UserContract.ts

@@ -1,7 +1,7 @@
 import { Address, beginCell, Cell, Contract, ContractProvider, Dictionary, Sender, SendMode } from '@ton/core';
 import { UserData, UserLiteData } from '../types/User';
 import { parseUserData, parseUserLiteData } from '../api/parser';
-import { AssetConfig, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, PoolConfig } from '../types/Master';
+import { ExtendedAssetsConfig, ExtendedAssetsData, PoolConfig } from '../types/Master';
 import { LiquidationBaseData } from './MasterContract';
 import { OPCODES } from '../constants/general';
 import { MAINNET_POOL_CONFIG } from '../constants/pools';
@@ -41,8 +41,7 @@ export class EvaaUser implements Contract {
                 state.data!.toString('base64'),
                 assetsData,
                 assetsConfig,
-                this.poolConfig.poolAssetsConfig,
-                this.poolConfig.masterConstants
+                this.poolConfig
             );
             this.lastSync = Math.floor(Date.now() / 1000);
         } else {
@@ -64,7 +63,7 @@ export class EvaaUser implements Contract {
         prices: Dictionary<bigint, bigint>,
     ): boolean {
         if (this._liteData) {
-            this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.poolConfig.poolAssetsConfig, this.poolConfig.masterConstants);
+            this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.poolConfig);
             return true;
         }
         return false;
@@ -104,10 +103,9 @@ export class EvaaUser implements Contract {
                 state.data!.toString('base64'),
                 assetsData,
                 assetsConfig,
-                this.poolConfig.poolAssetsConfig,
-                this.poolConfig.masterConstants
+                this.poolConfig
             );
-            this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.poolConfig.poolAssetsConfig, this.poolConfig.masterConstants);
+            this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.poolConfig);
             this.lastSync = Math.floor(Date.now() / 1000);
         } else {
             this._data = { type: 'inactive' };
@@ -153,11 +151,11 @@ export class EvaaUser implements Contract {
 
         return {
             borrowerAddress: this._data.ownerAddress,
-            loanAsset: this._data.liquidationData.greatestLoanAsset,
-            collateralAsset: this._data.liquidationData.greatestCollateralAsset,
+            loanAsset: this._data.liquidationData.greatestLoanAsset.assetId,
+            collateralAsset: this._data.liquidationData.greatestCollateralAsset.assetId,
             minCollateralAmount: this._data.liquidationData.minCollateralAmount,
             liquidationAmount: this._data.liquidationData.liquidationAmount,
-            tonLiquidation: this._data.liquidationData.greatestLoanAsset === TON_MAINNET.assetId,
+            tonLiquidation: this._data.liquidationData.greatestLoanAsset.assetId === TON_MAINNET.assetId,
         };
     }
 }

package/src/index.ts

@@ -24,13 +24,8 @@ export { getPrices } from './api/prices';
 export { JettonWallet } from './contracts/JettonWallet';
 export {
     EvaaParameters,
-    JettonMessageParameters,
-    TonSupplyParameters,
-    JettonSupplyParameters,
     WithdrawParameters,
     LiquidationBaseData,
-    TonLiquidationParameters,
-    JettonLiquidationParameters,
     Evaa,
 } from './contracts/MasterContract';
 export { EvaaUser } from './contracts/UserContract';
@@ -81,10 +76,10 @@ export {
     MAINNET_POOL_CONFIG,
     TESTNET_POOL_CONFIG,
     MAINNET_LP_POOL_CONFIG,
-    TESTNET_LP_POOL_CONFIG
 } from './constants/pools';
 
 export {
+    UNDEFINED_ASSET,
     TON_MAINNET,
     USDT_MAINNET,
     TONUSDT_DEDUST_MAINNET,
@@ -100,6 +95,7 @@ export {
 } from './constants/assets';
 
 export * from './constants/assets'
+export * from './utils/utils'
 
 // Utils
 export { getLastSentBoc, getTonConnectSender } from './utils/tonConnectSender';

package/src/types/Master.ts

@@ -6,19 +6,15 @@ export type MasterConstants = {
     ASSET_PRICE_SCALE: bigint,
     ASSET_RESERVE_FACTOR_SCALE: bigint,
     ASSET_LIQUIDATION_RESERVE_FACTOR_SCALE: bigint,
+    ASSET_LIQUIDATION_THRESHOLD_SCALE: bigint,
+    ASSET_LIQUIDATION_BONUS_SCALE: bigint,
     ASSET_ORIGINATION_FEE_SCALE: bigint
 };
 
-export type PoolAssetConfig = (PoolTonAssetConfig | PoolJettonAssetConfig) & {
-    name: string;
-};
 export type PoolAssetsConfig = PoolAssetConfig[];
 
-export type PoolTonAssetConfig = {
-    assetId: bigint;
-}
-
-export type PoolJettonAssetConfig = {
+export type PoolAssetConfig = {
+    name: string;
     assetId: bigint;
     jettonMasterAddress: Address;
     jettonWalletCode: Cell;
@@ -115,3 +111,8 @@ export type MasterData = {
         borrow: Dictionary<bigint, number>;
     };
 };
+
+export type AgregatedBalances = {
+    totalBorrow: bigint;
+    totalSupply: bigint;
+}

package/src/types/User.ts

@@ -1,5 +1,5 @@
 import { Address, Cell, Dictionary } from '@ton/core';
-import { AssetConfig, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants } from './Master';
+import { AssetConfig, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants, PoolAssetConfig, PoolConfig } from './Master';
 
 export enum BalanceType {
     supply = 'supply',
@@ -13,9 +13,9 @@ export type UserBalance = {
 
 export type UserLiqudationData = {
     greatestCollateralValue: bigint;
-    greatestCollateralAsset: bigint;
+    greatestCollateralAsset: PoolAssetConfig;
     greatestLoanValue: bigint;
-    greatestLoanAsset: bigint;
+    greatestLoanAsset: PoolAssetConfig;
     totalDebt: bigint;
     totalLimit: bigint;
 };
@@ -86,9 +86,9 @@ export type PredictHealthFactorArgs = {
     balanceChangeType: BalanceChangeType;
     amount: bigint;  // always positive
     tokenSymbol: string;
-    balances: Dictionary<bigint, bigint>;
+    principals: Dictionary<bigint, bigint>;
     prices: Dictionary<bigint, bigint>;
     assetsData: ExtendedAssetsData;
     assetsConfig: ExtendedAssetsConfig;
-    masterConstants: MasterConstants;
+    poolConfig: PoolConfig;
 };

package/src/utils/userJettonWallet.ts

@@ -1,7 +1,11 @@
 import { Address, beginCell, Cell, storeStateInit } from '@ton/core';
-import { PoolAssetConfig, PoolJettonAssetConfig } from '../types/Master';
+import { PoolAssetConfig } from '../types/Master';
+import { UNDEFINED_ASSET } from '../constants/assets';
 
-export function getUserJettonWallet(ownerAddress: Address, poolAssetConfig: PoolAssetConfig & PoolJettonAssetConfig) {
+export function getUserJettonWallet(ownerAddress: Address, poolAssetConfig: PoolAssetConfig) {
+  if (poolAssetConfig.name == 'TON' || poolAssetConfig.assetId === UNDEFINED_ASSET.assetId) {
+    throw new Error(`Cant getUserJettonWallet for ${poolAssetConfig.name} asset`)
+  }
     const jettonMasterAddress = poolAssetConfig.jettonMasterAddress;
     const jettonWalletCode = poolAssetConfig.jettonWalletCode;
 

package/src/utils/utils.ts

@@ -0,0 +1,6 @@
+import { PoolAssetConfig } from "../types/Master";
+
+export function isTonAsset(asset: PoolAssetConfig) {
+    return asset.name === 'TON';
+}
+