@evaafi/sdk 0.6.2 → 0.6.3

package/dist/rewards/RewardUser.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardUser = void 0;
+const crypto_1 = require("@ton/crypto");
+const ton_1 = require("@ton/ton");
+const general_1 = require("../constants/general");
+const sha256BigInt_1 = require("../utils/sha256BigInt");
+class RewardUser {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new RewardUser(address);
+    }
+    static rewardUserConfigToCell(config) {
+        return (0, ton_1.beginCell)()
+            .storeAddress(config.userAddress)
+            .storeCoins(0)
+            .storeRef((0, ton_1.beginCell)()
+            .storeAddress(config.rewardMasterAddress)
+            .storeBuffer((0, sha256BigInt_1.bigIntToBuffer)(config.asset.assetId), 256 / 8)
+            .storeBuffer(config.publicKey, 256 / 8)
+            .endCell())
+            .endCell();
+    }
+    static createFromConfig(config, workchain = 0) {
+        const data = this.rewardUserConfigToCell(config);
+        const init = { code: config.rewardUserCode, data };
+        return new RewardUser((0, ton_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via) {
+        await provider.internal(via, {
+            value: general_1.FEES.REWARD_MASTER_DEPLOY,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)().endCell(),
+        });
+    }
+    claimMessageToCell(claimAmount) {
+        return (0, ton_1.beginCell)().storeAddress(this.address).storeCoins(claimAmount).endCell();
+    }
+    signClaimMessage(claimBody, privateKey) {
+        return (0, ton_1.beginCell)()
+            .storeUint(general_1.OPCODES.REWARD_CLAIM, 32)
+            .storeUint(0, 64)
+            .storeBuffer((0, crypto_1.sign)(claimBody.hash(), privateKey))
+            .storeRef(claimBody)
+            .endCell();
+    }
+    async sendClaim(provider, via, signedClaimMessage) {
+        await provider.internal(via, {
+            value: general_1.FEES.REWARD_USER_CLAIM,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: signedClaimMessage,
+        });
+    }
+    async getData(provider) {
+        const result = await provider.get('load_data', []);
+        // TODO: maybe it will be typed
+        const data = {
+            userAddress: result.stack.readAddress(),
+            baseTrackingAccrued: Number((0, ton_1.fromNano)(result.stack.readBigNumber())),
+            rewardMasterAddress: result.stack.readAddress(),
+            assetId: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+            publicKey: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+        };
+        return data;
+    }
+}
+exports.RewardUser = RewardUser;

package/dist/types/MasterRewards.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Address, Cell } from '@ton/ton';
+import { PoolAssetConfig } from './Master';
+export type EvaaRewardsConfig = {
+    workchain?: number;
+    adminAddress: Address;
+    evaaMasterAddress: Address;
+    availableReward: number;
+    asset: PoolAssetConfig;
+    rewardMasterCode: Cell;
+    rewardUserCode: Cell;
+    publicKey: Buffer;
+};

package/dist/types/User.d.ts

@@ -1,5 +1,5 @@
 import { Address, Cell, Dictionary } from '@ton/core';
-import { ExtendedAssetsConfig, ExtendedAssetsData, PoolAssetConfig, PoolConfig } from './Master';
+import { AssetConfig, AssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, PoolAssetConfig, PoolConfig } from './Master';
 export declare enum BalanceType {
     supply = "supply",
     borrow = "borrow"
@@ -31,6 +31,7 @@ export type UserLiteData = {
     masterAddress: Address;
     ownerAddress: Address;
     principals: Dictionary<bigint, bigint>;
+    realPrincipals: Dictionary<bigint, bigint>;
     state: number;
     balances: Dictionary<bigint, UserBalance>;
     trackingSupplyIndex: bigint;
@@ -40,6 +41,7 @@ export type UserLiteData = {
     rewards: Dictionary<bigint, UserRewards>;
     backupCell1: Cell | null;
     backupCell2: Cell | null;
+    fullyParsed: boolean;
 };
 export type UserDataActive = UserLiteData & {
     withdrawalLimits: Dictionary<bigint, bigint>;
@@ -52,6 +54,7 @@ export type UserDataActive = UserLiteData & {
     limitUsed: bigint;
     healthFactor: number;
     liquidationData: LiquidationData;
+    havePrincipalWithoutPrice: boolean;
 };
 export type UserDataInactive = {
     type: 'inactive';
@@ -84,3 +87,10 @@ export type PredictHealthFactorArgs = {
     assetsConfig: ExtendedAssetsConfig;
     poolConfig: PoolConfig;
 };
+export type PredictAPYArgs = {
+    balanceChangeType: BalanceChangeType;
+    amount: bigint;
+    assetData: AssetData;
+    assetConfig: AssetConfig;
+    masterConstants: MasterConstants;
+};

package/dist/types/UserRewards.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Address, Cell } from '@ton/ton';
+import { PoolAssetConfig } from './Master';
+export type EvaaUserRewardsConfig = {
+    userAddress: Address;
+    rewardUserCode: Cell;
+    rewardMasterAddress: Address;
+    asset: PoolAssetConfig;
+    publicKey: Buffer;
+};

package/dist/types/UserRewards.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/sha256BigInt.d.ts

@@ -1 +1,3 @@
+/// <reference types="node" />
 export declare function sha256Hash(input: string): bigint;
+export declare function bigIntToBuffer(value: bigint): Buffer;

package/dist/utils/sha256BigInt.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha256Hash = void 0;
+exports.bigIntToBuffer = exports.sha256Hash = void 0;
 const sha256_1 = __importDefault(require("crypto-js/sha256"));
 function sha256Hash(input) {
     const hash = (0, sha256_1.default)(input);
@@ -11,3 +11,11 @@ function sha256Hash(input) {
     return BigInt('0x' + hashHex);
 }
 exports.sha256Hash = sha256Hash;
+function bigIntToBuffer(value) {
+    let hex = value.toString(16);
+    if (hex.length % 2) {
+        hex = '0' + hex;
+    }
+    return Buffer.from(hex, 'hex');
+}
+exports.bigIntToBuffer = bigIntToBuffer;

package/dist/utils/userJettonWallet.js

@@ -31,6 +31,13 @@ function getUserJettonData(ownerAddress, assetName, jettonWalletCode, jettonMast
                 .storeCoins(0)
                 .storeUint(0, 48)
                 .endCell();
+        case 'tgBTC':
+            return (0, core_1.beginCell)()
+                .storeUint(0, 4)
+                .storeCoins(0)
+                .storeAddress(ownerAddress)
+                .storeAddress(jettonMasterAddress)
+                .endCell();
         default:
             return (0, core_1.beginCell)().storeCoins(0)
                 .storeAddress(ownerAddress)

package/package.json

@@ -1,44 +1,44 @@
 {
-  "name": "@evaafi/sdk",
-  "version": "0.6.2",
-  "description": "The EVAA SDK is designed to easily integrate with the EVAA lending protocol on TON blockchain.",
-  "main": "dist/index.js",
-  "files": [
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "tsc --declaration",
-    "test": "jest"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/evaafi/sdk.git"
-  },
-  "author": "EVAA Finance",
-  "license": "MIT",
-  "homepage": "https://github.com/evaafi/sdk#readme",
-  "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",
-    "crypto-js": "^4.2.0",
-    "prettier": "^3.2.4",
-    "ts-jest": "^29.2.4",
-    "ts-node": "^10.9.1",
-    "typedoc": "^0.27.4",
-    "typescript": "^5.3.3"
-  },
-  "peerDependencies": {
-    "@ton/core": ">=0.56.0",
-    "@tonconnect/sdk": ">=3.0.0",
-    "crypto-js": ">=4.2.0"
-  },
-  "dependencies": {
-    "@ton/ton": "^14.0.0",
-    "dotenv": "^16.4.5"
-  }
+    "name": "@evaafi/sdk",
+    "version": "0.6.3",
+    "description": "The EVAA SDK is designed to easily integrate with the EVAA lending protocol on TON blockchain.",
+    "main": "dist/index.js",
+    "files": [
+        "dist",
+        "src"
+    ],
+    "scripts": {
+        "build": "tsc --declaration",
+        "test": "jest"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/evaafi/sdk.git"
+    },
+    "author": "EVAA Finance",
+    "license": "MIT",
+    "homepage": "https://github.com/evaafi/sdk#readme",
+    "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",
+        "crypto-js": "4.2.0",
+        "prettier": "3.2.4",
+        "ts-jest": "^29.2.4",
+        "ts-node": "^10.9.1",
+        "typedoc": "0.27.4",
+        "typescript": "5.3.3"
+    },
+    "peerDependencies": {
+        "@ton/core": ">=0.56.0",
+        "@tonconnect/sdk": ">=3.0.0",
+        "crypto-js": ">=4.2.0"
+    },
+    "dependencies": {
+        "@ton/ton": "14.0.0",
+        "dotenv": "16.4.5"
+    }
 }

package/src/api/math.ts

@@ -1,5 +1,6 @@
 import {
     AgregatedBalances,
+    AssetApy,
     AssetConfig,
     AssetData,
     AssetInterest,
@@ -15,6 +16,7 @@ import {
     BalanceType,
     HealthParamsArgs,
     LiquidationData,
+    PredictAPYArgs,
     PredictHealthFactorArgs,
     UserBalance
 } from '../types/User';
@@ -53,6 +55,12 @@ export function calculatePresentValue(index: bigint, principalValue: bigint, mas
     return (principalValue * index) / masterConstants.FACTOR_SCALE;
 }
 
+export function getAssetLiquidityMinusReserves(assetData: AssetData, masterConstants: MasterConstants) {
+    const total_supply = calculatePresentValue(assetData.sRate, assetData.totalSupply, masterConstants);
+    const total_borrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow, masterConstants);
+    return bigIntMin(total_supply - total_borrow, assetData.balance);
+}
+
 export function calculateCurrentRates(assetConfig: AssetConfig, assetData: AssetData, masterConstants: MasterConstants) {
     const now = BigInt(Math.floor(Date.now() / 1000));
     const timeElapsed = now - assetData.lastAccural;
@@ -109,9 +117,28 @@ export function calculateAssetData(
     };
 }
 
-export function calculateAssetInterest(assetConfig: AssetConfig, assetData: AssetData, masterConstants: MasterConstants): AssetInterest {
+export function calculateAssetInterest(
+    assetConfig: AssetConfig,
+    assetData: AssetData,
+    masterConstants: MasterConstants
+): AssetInterest {
     const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply, masterConstants);
     const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow, masterConstants);
+
+    return calculateInterestWithSupplyBorrow(
+        totalSupply,
+        totalBorrow,
+        assetConfig,
+        masterConstants
+    );
+}
+
+export function calculateInterestWithSupplyBorrow(
+    totalSupply: bigint,
+    totalBorrow: bigint,
+    assetConfig: AssetConfig,
+    masterConstants: MasterConstants
+): AssetInterest {
     let utilization = 0n;
     let supplyInterest = 0n;
     let borrowInterest = 0n;
@@ -147,6 +174,7 @@ export function calculateAssetInterest(assetConfig: AssetConfig, assetData: Asse
     };
 }
 
+
 export function checkNotInDebtAtAll(principals: Dictionary<bigint, bigint>): boolean {
     return principals.values().every(x => x >= 0n);
 }
@@ -250,10 +278,19 @@ export function getAvailableToBorrow(
     let borrowAmount = 0n;
 
     for (const assetID of principals.keys()) {
+        const principal = principals.get(assetID) as bigint;
+        
+        if (principal == 0n) {
+            continue;
+        }
+
+        if (!prices.has(assetID)) {
+            return 0n;
+        }
+
         const assetConfig = assetsConfig.get(assetID) as AssetConfig;
         const assetData = assetsData.get(assetID) as ExtendedAssetData;
         const price = prices.get(assetID) as bigint;
-        const principal = principals.get(assetID) as bigint;
 
         if (principal < 0n) {
             borrowAmount += mulDiv(calculatePresentValue(assetData.bRate, -principal, masterConstants), price, 10n ** assetConfig.decimals);
@@ -464,7 +501,6 @@ export function predictHealthFactor(args: PredictHealthFactorArgs): number {
 
     const assetConfig = args.assetsConfig.get(assetId)!;
     const assetPrice = Number(args.prices.get(assetId)!);
-const assetData = args.assetsData.get(assetId)!;
 
     let totalLimit = Number(healthParams.totalLimit);
     let totalBorrow = Number(healthParams.totalDebt);
@@ -493,3 +529,42 @@ const assetData = args.assetsData.get(assetId)!;
 
     return Math.min(Math.max(1 - totalBorrow / totalLimit, 0), 1);  // let's limit a result to zero below and one above
 }
+
+/**
+ * Predicts how APY will change as a result of one of the actions Borrow, Supply, Withdraw or Repay. 
+ *
+ * Used on the front-end. 
+ *
+ * @returns Estimated APYs for Supply and Borrow
+ */
+export function predictAPY(args: PredictAPYArgs): AssetInterest & AssetApy {
+    const assetConfig = args.assetConfig;
+    const assetData = args.assetData;
+    const masterConstants = args.masterConstants;
+
+    let totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply, masterConstants);
+    let totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow, masterConstants);
+
+    const currentAmount = args.amount;
+    const changeType = args.balanceChangeType;
+
+    if (currentAmount != null && currentAmount != 0n) {
+        if (changeType == BalanceChangeType.Borrow) {
+            totalBorrow += currentAmount;
+        } else if (changeType == BalanceChangeType.Repay) {
+            totalBorrow -= currentAmount;
+        } else if (changeType == BalanceChangeType.Withdraw) {
+            totalSupply -= currentAmount;
+        } else if (changeType == BalanceChangeType.Supply) {
+            totalSupply += currentAmount;
+        }
+    }
+
+    const interest = calculateInterestWithSupplyBorrow(totalSupply, totalBorrow, assetConfig, masterConstants);
+
+    return {
+        ...interest,
+        supplyApy: (1 + (Number(interest.supplyInterest) / 1e12) * 24 * 3600) ** 365 - 1,
+        borrowApy: (1 + (Number(interest.borrowInterest) / 1e12) * 24 * 3600) ** 365 - 1
+    }
+}

package/src/api/parser.ts

@@ -7,11 +7,13 @@ import {
     calculateLiquidationData,
     calculateMaximumWithdrawAmount,
     calculatePresentValue,
+    getAssetLiquidityMinusReserves,
     getAvailableToBorrow,
     presentValue,
 } from './math';
 import { loadMaybeMyRef, loadMyRef } from './helpers';
 import { BalanceType, UserBalance, UserData, UserLiteData, UserRewards } from '../types/User';
+import { checkNotInDebtAtAll } from "../api/math";
 
 export function createUserRewards(): DictionaryValue<UserRewards> {
     return {
@@ -32,8 +34,8 @@ export function createAssetData(): DictionaryValue<AssetData> {
         serialize: (src: any, buidler: any) => {
             buidler.storeUint(src.sRate, 64);
             buidler.storeUint(src.bRate, 64);
-            buidler.storeUint(src.totalSupply, 64);
-            buidler.storeUint(src.totalBorrow, 64);
+            buidler.storeInt(src.totalSupply, 64);
+            buidler.storeInt(src.totalBorrow, 64);
             buidler.storeUint(src.lastAccural, 32);
             buidler.storeUint(src.balance, 64);
             buidler.storeUint(src.trackingSupplyIndex, 64);
@@ -41,15 +43,15 @@ export function createAssetData(): DictionaryValue<AssetData> {
             buidler.storeUint(src.awaitedSupply, 64);
         },
         parse: (src: Slice) => {
-            const sRate = BigInt(src.loadInt(64));
-            const bRate = BigInt(src.loadInt(64));
-            const totalSupply = BigInt(src.loadInt(64));
-            const totalBorrow = BigInt(src.loadInt(64));
-            const lastAccural = BigInt(src.loadInt(32));
-            const balance = BigInt(src.loadInt(64));
-            const trackingSupplyIndex = BigInt(src.loadUint(64));
-            const trackingBorrowIndex = BigInt(src.loadUint(64));
-            const awaitedSupply = BigInt(src.loadUint(64));  
+            const sRate = BigInt(src.loadUintBig(64));
+            const bRate = BigInt(src.loadUintBig(64));
+            const totalSupply = BigInt(src.loadIntBig(64));
+            const totalBorrow = BigInt(src.loadIntBig(64));
+            const lastAccural = BigInt(src.loadUintBig(32));
+            const balance = BigInt(src.loadUintBig(64));
+            const trackingSupplyIndex = BigInt(src.loadUintBig(64));
+            const trackingBorrowIndex = BigInt(src.loadUintBig(64));
+            const awaitedSupply = BigInt(src.loadUintBig(64));  
 
             return { sRate, bRate, totalSupply, totalBorrow, lastAccural, balance, trackingSupplyIndex, trackingBorrowIndex, awaitedSupply};
         },
@@ -208,7 +210,8 @@ export function parseUserLiteData(
     const codeVersion = userSlice.loadCoins();
     const masterAddress = userSlice.loadAddress();
     const userAddress = userSlice.loadAddress();
-    const principalsDict = userSlice.loadDict(Dictionary.Keys.BigUint(256), Dictionary.Values.BigInt(64));
+    const realPrincipals = userSlice.loadDict(Dictionary.Keys.BigUint(256), Dictionary.Values.BigInt(64));
+    const principalsDict = Dictionary.empty(Dictionary.Keys.BigUint(256), Dictionary.Values.BigInt(64));
     const userState = userSlice.loadInt(64);
 
     let trackingSupplyIndex = 0n;
@@ -237,7 +240,7 @@ export function parseUserLiteData(
         const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
 
-        let principal = principalsDict.get(asset.assetId) || 0n;
+        let principal = realPrincipals.get(asset.assetId) || 0n;
         let balance = presentValue(assetData.sRate, assetData.bRate, principal, masterConstants);
 
         if (applyDust && (principal > 0 && (principal < assetConfig.dust))) {
@@ -247,6 +250,8 @@ export function parseUserLiteData(
                 type: BalanceType.supply,
             };
             principalsDict.set(asset.assetId, 0n);
+        } else {
+            principalsDict.set(asset.assetId, principal);
         }
         userBalances.set(asset.assetId, balance);
     }
@@ -257,12 +262,14 @@ export function parseUserLiteData(
         masterAddress: masterAddress,
         ownerAddress: userAddress,
         principals: principalsDict,
+        realPrincipals: realPrincipals,
         state: userState,
         balances: userBalances,
         trackingSupplyIndex: trackingSupplyIndex,
         trackingBorrowIndex: trackingBorrowIndex,
         dutchAuctionStart: dutchAuctionStart,
         backupCell: backupCell,
+        fullyParsed: false,
         
         rewards: rewards,
         backupCell1: backupCell1,
@@ -278,6 +285,9 @@ export function parseUserData(
     poolConfig: PoolConfig,
     applyDust: boolean = false
 ): UserData {
+    userLiteData.fullyParsed = true;
+    let havePrincipalWithoutPrice = false;
+
     const poolAssetsConfig = poolConfig.poolAssetsConfig;
     const masterConstants = poolConfig.masterConstants;
 
@@ -287,6 +297,16 @@ export function parseUserData(
     let supplyBalance = 0n;
     let borrowBalance = 0n;
 
+    for (const [assetId, principal] of userLiteData.realPrincipals) {
+        if (!prices.has(assetId)) {
+            userLiteData.fullyParsed = false;
+
+            if (principal != 0n) {
+                havePrincipalWithoutPrice = true;
+            }
+        }
+    }
+
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
@@ -303,6 +323,10 @@ export function parseUserData(
     }
 
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
+        if (!prices.has(asset.assetId)) {
+            continue;
+        }
+
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
         const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
 
@@ -314,22 +338,30 @@ export function parseUserData(
         }
     }
 
-    const availableToBorrow = getAvailableToBorrow(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants);
+    const availableToBorrow = getAvailableToBorrow(assetsConfig, assetsData, userLiteData.realPrincipals, prices, masterConstants);
+
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
+        const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
         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;
         
+        const assetLiquidityMinusReserves = getAssetLiquidityMinusReserves(assetData, masterConstants);
+
         if (balance.type === BalanceType.supply) {
             withdrawalLimits.set(
                 asset.assetId,
-                bigIntMin(calculateMaximumWithdrawAmount(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants, asset.assetId), assetData.balance)
+                bigIntMin(calculateMaximumWithdrawAmount(assetsConfig, assetsData, userLiteData.realPrincipals, prices, masterConstants, asset.assetId), assetData.balance)
             );
         }
 
+        if (!prices.has(asset.assetId)) {
+            borrowLimits.set(asset.assetId, 0n);
+            continue;
+        }
+
         borrowLimits.set(
             asset.assetId,
-            bigIntMax(0n, bigIntMin((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(asset.assetId)!, assetData.balance, assetData.totalSupply - assetData.totalBorrow)),
+            bigIntMax(0n, bigIntMin((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(asset.assetId)!, assetLiquidityMinusReserves)),
         );
     }
 
@@ -339,12 +371,14 @@ export function parseUserData(
             ? 0
             : Number(BigInt(1e9) - (availableToBorrow * BigInt(1e9)) / (borrowBalance + availableToBorrow)) / 1e7;
 
-    const liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.principals, prices, poolConfig);
     let healthFactor = 1;
-    if (liquidationData.totalLimit != 0n) {
-        healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
-    } 
-
+    let liquidationData;
+    if (!havePrincipalWithoutPrice) {
+        liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.realPrincipals, prices, poolConfig);
+        if (liquidationData.totalLimit != 0n) {
+            healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
+        } 
+    }
     return {
         ...userLiteData,
         withdrawalLimits: withdrawalLimits,
@@ -356,5 +390,6 @@ export function parseUserData(
         limitUsed: limitUsed,
         liquidationData: liquidationData,
         healthFactor: healthFactor,
+        havePrincipalWithoutPrice: havePrincipalWithoutPrice
     };
 }