@evaafi/sdk 0.6.0 → 0.6.1

package/dist/contracts/UserContract.js

@@ -13,6 +13,7 @@ class EvaaUser {
     /**
      * Create user contract wrapper from address
      * @param address user contract address
+     * @param poolConfig pool config
      */
     static createFromAddress(address, poolConfig = pools_1.MAINNET_POOL_CONFIG) {
         return new EvaaUser(address, poolConfig);
@@ -22,10 +23,10 @@ class EvaaUser {
         this.address = address;
         this.poolConfig = poolConfig;
     }
-    async getSyncLite(provider, assetsData, assetsConfig) {
+    async getSyncLite(provider, assetsData, assetsConfig, applyDust = false) {
         const state = (await provider.getState()).state;
         if (state.type === 'active') {
-            this._liteData = (0, parser_1.parseUserLiteData)(state.data.toString('base64'), assetsData, assetsConfig, this.poolConfig);
+            this._liteData = (0, parser_1.parseUserLiteData)(state.data.toString('base64'), assetsData, assetsConfig, this.poolConfig, applyDust);
             this.lastSync = Math.floor(Date.now() / 1000);
         }
         else {
@@ -62,11 +63,11 @@ class EvaaUser {
                 .endCell(),
         });
     }
-    async getSync(provider, assetsData, assetsConfig, prices) {
+    async getSync(provider, assetsData, assetsConfig, prices, applyDust = false) {
         const state = (await provider.getState()).state;
         if (state.type === 'active') {
-            this._liteData = (0, parser_1.parseUserLiteData)(state.data.toString('base64'), assetsData, assetsConfig, this.poolConfig);
-            this._data = (0, parser_1.parseUserData)(this._liteData, assetsData, assetsConfig, prices, this.poolConfig);
+            this._liteData = (0, parser_1.parseUserLiteData)(state.data.toString('base64'), assetsData, assetsConfig, this.poolConfig, applyDust);
+            this._data = (0, parser_1.parseUserData)(this._liteData, assetsData, assetsConfig, prices, this.poolConfig, applyDust);
             this.lastSync = Math.floor(Date.now() / 1000);
         }
         else {

package/dist/index.d.ts

@@ -1,15 +1,16 @@
-export { mulFactor, mulDiv, bigIntMin, bigIntMax, calculatePresentValue, calculateCurrentRates, calculateAssetData, calculateAssetInterest, getAvailableToBorrow, calculateMaximumWithdrawAmount, presentValue, calculateLiquidationData, predictHealthFactor } from './api/math';
+export { mulFactor, mulDiv, bigIntMin, bigIntMax, calculatePresentValue, calculateCurrentRates, calculateAssetData, calculateAssetInterest, getAvailableToBorrow, calculateMaximumWithdrawAmount, presentValue, calculateLiquidationData, predictHealthFactor, calculateHealthParams, BigMath, } from './api/math';
+export { calculateLiquidationAmounts, calculateMinCollateralByTransferredAmount, isLiquidatable, isBadDebt, addReserve, deductReserve, addLiquidationBonus, deductLiquidationBonus, toAssetAmount, toAssetWorth, PreparedAssetInfo, PreparedAssetInfoResult, prepareAssetInfo, findAssetById, selectGreatestAssets, calculateAssetsValues, AssetsValues, SelectedAssets, } from './api/liquidation';
 export { createAssetData, createAssetConfig, parseMasterData, parseUserData, parseUserLiteData } from './api/parser';
 export { getPrices } from './api/prices';
 export { JettonWallet } from './contracts/JettonWallet';
-export { EvaaParameters, WithdrawParameters, LiquidationBaseData, LiquidationParameters, Evaa, } from './contracts/MasterContract';
+export { EvaaParameters, WithdrawParameters, LiquidationBaseData, LiquidationParameters, Evaa } from './contracts/MasterContract';
 export { EvaaUser } from './contracts/UserContract';
 export { PriceData } from './types/Common';
 export { UpgradeConfig, AssetConfig, MasterConfig, AssetData, AssetInterest, AssetApy, ExtendedAssetData, MasterData, PoolConfig, ExtendedAssetsData, ExtendedAssetsConfig, PoolAssetConfig, PoolAssetsConfig, MasterConstants } from './types/Master';
 export { BalanceType, UserBalance, UserLiqudationData, LiquidableData, NonLiquidableData, LiquidationData, UserDataInactive, UserDataActive, UserData, BalanceChangeType } from './types/User';
 export { EVAA_MASTER_MAINNET, MAINNET_VERSION, EVAA_MASTER_TESTNET, TESTNET_VERSION, LENDING_CODE, OPCODES, FEES, MASTER_CONSTANTS } from './constants/general';
-export { MAINNET_POOL_CONFIG, TESTNET_POOL_CONFIG, MAINNET_LP_POOL_CONFIG, } from './constants/pools';
-export { UNDEFINED_ASSET, TON_MAINNET, USDT_MAINNET, TONUSDT_DEDUST_MAINNET, TON_STORM_MAINNET, USDT_STORM_MAINNET, JUSDT_MAINNET, JUSDC_MAINNET, STTON_MAINNET, TSTON_MAINNET, JUSDT_TESTNET, JUSDC_TESTNET, STTON_TESTNET, } from './constants/assets';
+export { MAINNET_POOL_CONFIG, TESTNET_POOL_CONFIG, MAINNET_LP_POOL_CONFIG } from './constants/pools';
+export { ASSET_ID, UNDEFINED_ASSET, TON_MAINNET, USDT_MAINNET, TONUSDT_DEDUST_MAINNET, TON_STORM_MAINNET, USDT_STORM_MAINNET, JUSDT_MAINNET, JUSDC_MAINNET, STTON_MAINNET, TSTON_MAINNET, JUSDT_TESTNET, JUSDC_TESTNET, STTON_TESTNET } from './constants/assets';
 export * from './constants/assets';
 export * from './utils/utils';
 export { getLastSentBoc, getTonConnectSender } from './utils/tonConnectSender';

package/dist/index.js

@@ -14,8 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTonConnectSender = exports.getLastSentBoc = exports.STTON_TESTNET = exports.JUSDC_TESTNET = exports.JUSDT_TESTNET = exports.TSTON_MAINNET = exports.STTON_MAINNET = exports.JUSDC_MAINNET = exports.JUSDT_MAINNET = exports.USDT_STORM_MAINNET = exports.TON_STORM_MAINNET = exports.TONUSDT_DEDUST_MAINNET = exports.USDT_MAINNET = exports.TON_MAINNET = exports.UNDEFINED_ASSET = exports.MAINNET_LP_POOL_CONFIG = exports.TESTNET_POOL_CONFIG = exports.MAINNET_POOL_CONFIG = exports.MASTER_CONSTANTS = exports.FEES = exports.OPCODES = exports.LENDING_CODE = exports.TESTNET_VERSION = exports.EVAA_MASTER_TESTNET = exports.MAINNET_VERSION = exports.EVAA_MASTER_MAINNET = exports.BalanceChangeType = exports.BalanceType = exports.EvaaUser = exports.Evaa = exports.JettonWallet = exports.getPrices = exports.parseUserLiteData = exports.parseUserData = exports.parseMasterData = exports.createAssetConfig = exports.createAssetData = exports.predictHealthFactor = exports.calculateLiquidationData = exports.presentValue = exports.calculateMaximumWithdrawAmount = exports.getAvailableToBorrow = exports.calculateAssetInterest = exports.calculateAssetData = exports.calculateCurrentRates = exports.calculatePresentValue = exports.bigIntMax = exports.bigIntMin = exports.mulDiv = exports.mulFactor = void 0;
-exports.getUserJettonWallet = void 0;
+exports.TESTNET_POOL_CONFIG = exports.MAINNET_POOL_CONFIG = exports.MASTER_CONSTANTS = exports.FEES = exports.OPCODES = exports.LENDING_CODE = exports.TESTNET_VERSION = exports.EVAA_MASTER_TESTNET = exports.MAINNET_VERSION = exports.EVAA_MASTER_MAINNET = exports.BalanceChangeType = exports.BalanceType = exports.EvaaUser = exports.Evaa = exports.JettonWallet = exports.getPrices = exports.parseUserLiteData = exports.parseUserData = exports.parseMasterData = exports.createAssetConfig = exports.createAssetData = exports.calculateAssetsValues = exports.selectGreatestAssets = exports.findAssetById = exports.prepareAssetInfo = exports.toAssetWorth = exports.toAssetAmount = exports.deductLiquidationBonus = exports.addLiquidationBonus = exports.deductReserve = exports.addReserve = exports.isBadDebt = exports.isLiquidatable = exports.calculateMinCollateralByTransferredAmount = exports.calculateLiquidationAmounts = exports.BigMath = exports.calculateHealthParams = exports.predictHealthFactor = exports.calculateLiquidationData = exports.presentValue = exports.calculateMaximumWithdrawAmount = exports.getAvailableToBorrow = exports.calculateAssetInterest = exports.calculateAssetData = exports.calculateCurrentRates = exports.calculatePresentValue = exports.bigIntMax = exports.bigIntMin = exports.mulDiv = exports.mulFactor = void 0;
+exports.getUserJettonWallet = exports.getTonConnectSender = exports.getLastSentBoc = exports.STTON_TESTNET = exports.JUSDC_TESTNET = exports.JUSDT_TESTNET = exports.TSTON_MAINNET = exports.STTON_MAINNET = exports.JUSDC_MAINNET = exports.JUSDT_MAINNET = exports.USDT_STORM_MAINNET = exports.TON_STORM_MAINNET = exports.TONUSDT_DEDUST_MAINNET = exports.USDT_MAINNET = exports.TON_MAINNET = exports.UNDEFINED_ASSET = exports.ASSET_ID = exports.MAINNET_LP_POOL_CONFIG = void 0;
 // Math
 var math_1 = require("./api/math");
 Object.defineProperty(exports, "mulFactor", { enumerable: true, get: function () { return math_1.mulFactor; } });
@@ -31,6 +31,23 @@ Object.defineProperty(exports, "calculateMaximumWithdrawAmount", { enumerable: t
 Object.defineProperty(exports, "presentValue", { enumerable: true, get: function () { return math_1.presentValue; } });
 Object.defineProperty(exports, "calculateLiquidationData", { enumerable: true, get: function () { return math_1.calculateLiquidationData; } });
 Object.defineProperty(exports, "predictHealthFactor", { enumerable: true, get: function () { return math_1.predictHealthFactor; } });
+Object.defineProperty(exports, "calculateHealthParams", { enumerable: true, get: function () { return math_1.calculateHealthParams; } });
+Object.defineProperty(exports, "BigMath", { enumerable: true, get: function () { return math_1.BigMath; } });
+var liquidation_1 = require("./api/liquidation");
+Object.defineProperty(exports, "calculateLiquidationAmounts", { enumerable: true, get: function () { return liquidation_1.calculateLiquidationAmounts; } });
+Object.defineProperty(exports, "calculateMinCollateralByTransferredAmount", { enumerable: true, get: function () { return liquidation_1.calculateMinCollateralByTransferredAmount; } });
+Object.defineProperty(exports, "isLiquidatable", { enumerable: true, get: function () { return liquidation_1.isLiquidatable; } });
+Object.defineProperty(exports, "isBadDebt", { enumerable: true, get: function () { return liquidation_1.isBadDebt; } });
+Object.defineProperty(exports, "addReserve", { enumerable: true, get: function () { return liquidation_1.addReserve; } });
+Object.defineProperty(exports, "deductReserve", { enumerable: true, get: function () { return liquidation_1.deductReserve; } });
+Object.defineProperty(exports, "addLiquidationBonus", { enumerable: true, get: function () { return liquidation_1.addLiquidationBonus; } });
+Object.defineProperty(exports, "deductLiquidationBonus", { enumerable: true, get: function () { return liquidation_1.deductLiquidationBonus; } });
+Object.defineProperty(exports, "toAssetAmount", { enumerable: true, get: function () { return liquidation_1.toAssetAmount; } });
+Object.defineProperty(exports, "toAssetWorth", { enumerable: true, get: function () { return liquidation_1.toAssetWorth; } });
+Object.defineProperty(exports, "prepareAssetInfo", { enumerable: true, get: function () { return liquidation_1.prepareAssetInfo; } });
+Object.defineProperty(exports, "findAssetById", { enumerable: true, get: function () { return liquidation_1.findAssetById; } });
+Object.defineProperty(exports, "selectGreatestAssets", { enumerable: true, get: function () { return liquidation_1.selectGreatestAssets; } });
+Object.defineProperty(exports, "calculateAssetsValues", { enumerable: true, get: function () { return liquidation_1.calculateAssetsValues; } });
 // Parser
 var parser_1 = require("./api/parser");
 Object.defineProperty(exports, "createAssetData", { enumerable: true, get: function () { return parser_1.createAssetData; } });
@@ -66,6 +83,7 @@ Object.defineProperty(exports, "MAINNET_POOL_CONFIG", { enumerable: true, get: f
 Object.defineProperty(exports, "TESTNET_POOL_CONFIG", { enumerable: true, get: function () { return pools_1.TESTNET_POOL_CONFIG; } });
 Object.defineProperty(exports, "MAINNET_LP_POOL_CONFIG", { enumerable: true, get: function () { return pools_1.MAINNET_LP_POOL_CONFIG; } });
 var assets_1 = require("./constants/assets");
+Object.defineProperty(exports, "ASSET_ID", { enumerable: true, get: function () { return assets_1.ASSET_ID; } });
 Object.defineProperty(exports, "UNDEFINED_ASSET", { enumerable: true, get: function () { return assets_1.UNDEFINED_ASSET; } });
 Object.defineProperty(exports, "TON_MAINNET", { enumerable: true, get: function () { return assets_1.TON_MAINNET; } });
 Object.defineProperty(exports, "USDT_MAINNET", { enumerable: true, get: function () { return assets_1.USDT_MAINNET; } });

package/dist/types/Master.d.ts

@@ -9,6 +9,9 @@ export type MasterConstants = {
     ASSET_LIQUIDATION_THRESHOLD_SCALE: bigint;
     ASSET_LIQUIDATION_BONUS_SCALE: bigint;
     ASSET_ORIGINATION_FEE_SCALE: bigint;
+    ASSET_SRATE_SCALE: bigint;
+    ASSET_BRATE_SCALE: bigint;
+    COLLATERAL_WORTH_THRESHOLD: bigint;
 };
 export type PoolAssetsConfig = PoolAssetConfig[];
 export type PoolAssetConfig = {

package/dist/types/User.d.ts

@@ -61,6 +61,13 @@ export type UserRewards = {
     trackingIndex: bigint;
     trackingAccured: bigint;
 };
+export type HealthParamsArgs = {
+    assetsData: ExtendedAssetsData;
+    assetsConfig: ExtendedAssetsConfig;
+    principals: Dictionary<bigint, bigint>;
+    prices: Dictionary<bigint, bigint>;
+    poolConfig: PoolConfig;
+};
 export declare enum BalanceChangeType {
     Borrow = 0,
     Repay = 1,

package/dist/utils/utils.d.ts

@@ -1,2 +1,3 @@
 import { PoolAssetConfig } from "../types/Master";
 export declare function isTonAsset(asset: PoolAssetConfig): boolean;
+export declare function isTonAssetId(assetId: bigint): boolean;

package/dist/utils/utils.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTonAsset = void 0;
+exports.isTonAssetId = exports.isTonAsset = void 0;
+const assets_1 = require("../constants/assets");
 function isTonAsset(asset) {
     return asset.name === 'TON';
 }
 exports.isTonAsset = isTonAsset;
+function isTonAssetId(assetId) {
+    return assetId === assets_1.ASSET_ID.TON;
+}
+exports.isTonAssetId = isTonAssetId;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@evaafi/sdk",
-  "version": "0.6.0",
-  "description": "SDK for EVAA v6 contracts",
+  "version": "0.6.1",
+  "description": "The EVAA SDK is designed to easily integrate with the EVAA lending protocol on TON blockchain.",
   "main": "dist/index.js",
   "files": [
     "dist",
@@ -20,6 +20,7 @@
   "devDependencies": {
     "@orbs-network/ton-access": "^2.3.3",
     "@ton/core": "0.56.0",
+    "@ton/crypto": "^3.3.0",
     "@tonconnect/sdk": "^3.0.5",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.10.4",

package/src/api/liquidation.ts

@@ -0,0 +1,346 @@
+import { Dictionary } from '@ton/core';
+import {
+    AssetConfig,
+    AssetData,
+    ExtendedAssetsConfig,
+    ExtendedAssetsData,
+    MasterConstants,
+    PoolAssetConfig,
+    PoolConfig
+} from '../types/Master';
+import { BigMath, calculateHealthParams, presentValue } from './math';
+import { BalanceType, UserBalance } from '../types/User';
+
+export function findAssetById(assetId: bigint, poolConfig: PoolConfig): PoolAssetConfig | undefined {
+    return poolConfig.poolAssetsConfig.find(asset => asset.assetId === assetId);
+}
+
+export type AssetsValues = {
+    loanAssets: Dictionary<bigint, bigint>,
+    collateralAssets: Dictionary<bigint, bigint>
+}
+
+export type SelectedAssets = {
+    selectedLoanId: bigint,
+    selectedCollateralId: bigint,
+    selectedLoanValue?: bigint,
+    selectedCollateralValue?: bigint,
+}
+
+export function calculateAssetsValues(
+    principalsDict: Dictionary<bigint, bigint>,
+    pricesDict: Dictionary<bigint, bigint>,
+    assetsConfigDict: ExtendedAssetsConfig,
+    assetsDataDict: ExtendedAssetsData,
+    poolConfig: PoolConfig
+): AssetsValues {
+    const loanAssets = Dictionary.empty<bigint, bigint>();
+    const collateralAssets = Dictionary.empty<bigint, bigint>();
+
+    for (const asset of poolConfig.poolAssetsConfig) {
+        const assetId = asset.assetId;
+        if (!principalsDict.has(assetId)) {
+            continue;
+        }
+        const assetPrincipal: bigint = principalsDict.get(assetId)!;
+        if (!pricesDict.has(assetId)) {
+            console.warn(`No price for asset ${asset.name}`);
+            continue;
+        }
+        const assetPrice = pricesDict.get(assetId)!;
+        if (!assetsDataDict.has(assetId)) {
+            console.warn(`Dynamics for assetId ${assetId} is not defined, skipping`);
+            continue;
+        }
+        const assetData = assetsDataDict.get(assetId)!;
+
+        if (!assetsConfigDict.has(assetId)) {
+            console.warn(`Config for assetId ${assetId} is not defined, skipping`);
+            continue;
+        }
+        const assetConfig = assetsConfigDict.get(assetId)!;
+        const assetScale = 10n ** assetConfig.decimals;
+        const { sRate, bRate } = assetData;
+        const assetPresent = presentValue(sRate, bRate, assetPrincipal, poolConfig.masterConstants);
+        const assetValue = assetPresent.amount * assetPrice / assetScale;
+        if (assetPresent.type === BalanceType.borrow) {
+            loanAssets.set(assetId, assetValue);
+        } else {
+            collateralAssets.set(assetId, assetValue);
+        }
+    }
+
+    return { loanAssets, collateralAssets };
+}
+
+export function selectGreatestAssets(principalsDict: Dictionary<bigint, bigint>,
+                                     pricesDict: Dictionary<bigint, bigint>,
+                                     assetsConfigDict: ExtendedAssetsConfig,
+                                     assetsDataDict: ExtendedAssetsData,
+                                     poolConfig: PoolConfig): SelectedAssets {
+    let maxLoanId = 0n;
+    let maxLoanValue = 0n;
+    let maxCollateralId = 0n;
+    let maxCollateralValue = 0n;
+
+    const assetsValues = calculateAssetsValues(principalsDict, pricesDict, assetsConfigDict, assetsDataDict, poolConfig);
+
+    for (const [loanId, loanValue] of assetsValues.loanAssets) {
+        if (loanValue > maxLoanValue) {
+            maxLoanId = loanId;
+            maxLoanValue = loanValue;
+        }
+    }
+
+    for (const [collateralId, collateralValue] of assetsValues.collateralAssets) {
+        if (collateralValue > maxCollateralValue) {
+            maxCollateralValue = collateralValue;
+            maxCollateralId = collateralId;
+        }
+    }
+
+    return {
+        selectedLoanId: maxLoanId,
+        selectedLoanValue: maxLoanValue,
+        selectedCollateralId: maxCollateralId,
+        selectedCollateralValue: maxCollateralValue
+    };
+}
+
+/**
+ * This function shows how to calculate min collateral amount value.
+ * when liquidator has not enough of loan asset to cover the full loan.
+ * @param transferredAmount amount of loan asset liquidator want to transfer.
+ * @param maxLiquidationAmount max liquidation amount value calculated.
+ * @param maxCollateralReward max collateral reward amount calculated.
+ * @returns minCollateralAmount value for safe liquidation.
+ */
+export function calculateMinCollateralByTransferredAmount(
+    transferredAmount: bigint, maxLiquidationAmount: bigint, maxCollateralReward: bigint
+) {
+    if (maxLiquidationAmount === 0n) {
+        return 0n;
+    }
+    return maxCollateralReward * transferredAmount / maxLiquidationAmount;
+}
+
+/**
+ * Calculates liquidation amount and corresponding collateral amount
+ * @param supplyAmount user total supply worth amount
+ * @param borrowAmount user total borrow worth amount
+ * @param masterConstants evaa master contract constants
+ * @param loanAsset loan asset pool config
+ * @param collateralAsset collateral asset pool config
+ * @param principalsDict user principals
+ * @param assetsDataDict assets data collection
+ * @param assetsConfigDict assets config collection
+ * @param pricesDict assets prices
+ * @returns maxLiquidationAmount max loan asset amount to transfer
+ * @returns maxCollateralRewardAmount max collateral reward amount, which can be obtained
+ */
+export function calculateLiquidationAmounts(
+    loanAsset: PoolAssetConfig,
+    collateralAsset: PoolAssetConfig,
+    supplyAmount: bigint,
+    borrowAmount: bigint, // from calculate health params
+    principalsDict: Dictionary<bigint, bigint>,
+    pricesDict: Dictionary<bigint, bigint>,
+    assetsDataDict: ExtendedAssetsData,
+    assetsConfigDict: ExtendedAssetsConfig,
+    masterConstants: MasterConstants
+): {
+    maxLiquidationAmount: bigint, maxCollateralRewardAmount: bigint
+} {
+    const loanInfo = prepareAssetInfo(loanAsset.assetId,
+        assetsConfigDict, assetsDataDict, pricesDict, principalsDict, masterConstants
+    );
+    const collateralInfo = prepareAssetInfo(collateralAsset.assetId,
+        assetsConfigDict, assetsDataDict, pricesDict, principalsDict, masterConstants
+    );
+
+    if (!loanInfo.ok || !collateralInfo.ok ||
+        loanInfo.present.type !== BalanceType.borrow ||
+        collateralInfo.present.type !== BalanceType.supply) {
+        return { maxLiquidationAmount: 0n, maxCollateralRewardAmount: 0n };
+    }
+
+    const liquidationBonusScale = masterConstants.ASSET_LIQUIDATION_BONUS_SCALE;
+    const collateralThreshold = masterConstants.COLLATERAL_WORTH_THRESHOLD; // basically 100$ worth (100*10^9)
+    const reserveFactorScale = masterConstants.ASSET_RESERVE_FACTOR_SCALE;
+    const reserveFactor = loanInfo.liquidationReserveFactor;
+    const liquidationBonus = collateralInfo.liquidationBonus;
+
+    let allowedCollateralValue = toAssetWorth(collateralInfo.balance, collateralInfo.scale, collateralInfo.price);
+
+    const _isBadDebt = isBadDebt(supplyAmount, borrowAmount, liquidationBonus, masterConstants);
+    if (!_isBadDebt) {
+        allowedCollateralValue = BigMath.min(allowedCollateralValue, BigMath.max(allowedCollateralValue / 2n, collateralThreshold));
+    }
+
+    const loanValue = toAssetWorth(loanInfo.balance, loanInfo.scale, loanInfo.price);
+    const baseLiquidationValue = BigMath.min(
+        // deductReserve(loanValue, reserveFactor, reserveFactorScale),
+        loanValue,
+        deductLiquidationBonus(allowedCollateralValue, liquidationBonus, liquidationBonusScale)
+    );
+
+    // calculate collateral amount
+    let collateralAmount = addLiquidationBonus(baseLiquidationValue, liquidationBonus, liquidationBonusScale);
+    collateralAmount = toAssetAmount(collateralAmount, collateralInfo.scale, collateralInfo.price);
+
+    // calculate loan amount
+    let liquidationAmount = addReserve(baseLiquidationValue, reserveFactor, reserveFactorScale);
+    liquidationAmount = toAssetAmount(liquidationAmount, loanInfo.scale, loanInfo.price);
+
+    return {
+        maxLiquidationAmount: liquidationAmount,
+        maxCollateralRewardAmount: collateralAmount
+    };
+}
+
+/**
+ * Check if the user is subject to liquidation
+ * @param args
+ */
+export function isLiquidatable(args: {
+    assetsData: ExtendedAssetsData, assetsConfig: ExtendedAssetsConfig,
+    principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>,
+    poolConfig: PoolConfig
+}): boolean {
+    const { isLiquidatable: res } = calculateHealthParams(args);
+    return res;
+}
+
+/**
+ * Determines if the provided pair of assets forms a bad debt.
+ * @param totalSupply total supply worth amount
+ * @param totalBorrow total borrow worth amount
+ * @param liquidationBonus collateral liquidation bonus value
+ * @param masterConstants pool constants
+ */
+export function isBadDebt(totalSupply: bigint, totalBorrow: bigint,
+                          liquidationBonus: bigint, masterConstants: MasterConstants
+) {
+    return totalSupply * masterConstants.ASSET_LIQUIDATION_BONUS_SCALE < totalBorrow * liquidationBonus;
+}
+
+/**
+ * Adds reserve to liquidation amount
+ * @param amount raw liquidation amount
+ * @param reserveFactor asset reserve factor
+ * @param factorScale asset reserve factor scale
+ * @returns liquidation amount with reserve
+ */
+export function addReserve(amount: bigint, reserveFactor: bigint, factorScale: bigint): bigint {
+    return amount * factorScale / (factorScale - reserveFactor);
+}
+
+/**
+ * Deducts reserve from liquidation amount
+ * @param amount liquidation amount with reserve
+ * @param reserveFactor asset reserve factor
+ * @param reserveFactorScale asset reserve factor scale
+ * @returns liquidation amount without reserve
+ */
+export function deductReserve(amount: bigint, reserveFactor: bigint, reserveFactorScale: bigint): bigint {
+    return amount * (reserveFactorScale - reserveFactor) / reserveFactorScale;
+}
+
+/**
+ * Converts worth value to specified asset amount
+ * @param worth worth value (decimals = 9)
+ * @param scale asset scale (10^asset_decimals)
+ * @param price asset price
+ */
+export function toAssetAmount(worth: bigint, scale: bigint, price: bigint): bigint {
+    return worth * scale / price;
+}
+
+/**
+ * Converts calculates worth value of specified asset amount
+ * @param amount worth value (decimals = 9)
+ * @param scale asset scale (10^asset_decimals)
+ * @param price asset price
+ */
+export function toAssetWorth(amount: bigint, scale: bigint, price: bigint): bigint {
+    return amount * price / scale;
+}
+
+/**
+ * Adds liquidation bonus to reward value.
+ * @param value reward asset value
+ * @param bonus liquidation bonus factor
+ * @param scale liquidation bonus scale
+ */
+export function addLiquidationBonus(value: bigint, bonus: bigint, scale: bigint): bigint {
+    return value * bonus / scale;
+}
+
+/**
+ * Deducts liquidation bonus from reward value.
+ * @param value reward asset value
+ * @param bonus liquidation bonus factor
+ * @param scale liquidation bonus scale
+ */
+export function deductLiquidationBonus(value: bigint, bonus: bigint, scale: bigint): bigint {
+    return value * scale / bonus;
+}
+
+export type SuccessType = { ok: true };
+export type FailType = { ok: false };
+
+export type PreparedAssetInfo = {
+    config: AssetConfig,
+    data: AssetData,
+    price: bigint,
+    principal: bigint,
+    scale: bigint,
+    liquidationReserveFactor: bigint,
+    liquidationBonus: bigint,
+    present: UserBalance,
+    balance: bigint,
+    dust: bigint,
+};
+
+export type PreparedAssetInfoResult = (PreparedAssetInfo & SuccessType) | FailType;
+
+/**
+ * Prepares extended asset info
+ * @param assetId
+ * @param assetsConfigDict
+ * @param assetsDataDict
+ * @param pricesDict
+ * @param principalsDict
+ * @param masterConstants
+ */
+export function prepareAssetInfo(assetId: bigint,
+                                 assetsConfigDict: ExtendedAssetsConfig,
+                                 assetsDataDict: ExtendedAssetsData,
+                                 pricesDict: Dictionary<bigint, bigint>,
+                                 principalsDict: Dictionary<bigint, bigint>,
+                                 masterConstants: MasterConstants
+): PreparedAssetInfoResult {
+    if (!assetsConfigDict.has(assetId) ||
+        !assetsDataDict.has(assetId) ||
+        !pricesDict.has(assetId) ||
+        !principalsDict.has(assetId)) {
+        return { ok: false };
+    }
+
+    const config = assetsConfigDict.get(assetId)!;
+    const data = assetsDataDict.get(assetId)!;
+    const base = {
+        ok: true,
+        config, data,
+        price: pricesDict.get(assetId)!,
+        principal: principalsDict.get(assetId)!,
+        scale: 10n ** config.decimals,
+        liquidationReserveFactor: config.liquidationReserveFactor,
+        liquidationBonus: config.liquidationBonus
+    };
+
+    const assetPresent = presentValue(data.sRate, data.bRate, base.principal, masterConstants);
+    const dustPresent = presentValue(data.sRate, data.bRate, config.dust, masterConstants);
+
+    return { ...base, present: assetPresent, balance: assetPresent.amount, dust: dustPresent.amount };
+}