@evaafi/sdk 0.9.5 → 0.9.6

package/dist/api/math.d.ts

@@ -1,6 +1,6 @@
 import { Dictionary } from '@ton/core';
-import { AgregatedBalances, AssetApy, AssetConfig, AssetData, AssetInterest, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, PoolConfig } from '../types/Master';
-import { HealthParamsArgs, LiquidationData, PredictAPYArgs, PredictHealthFactorArgs, UserBalance } from '../types/User';
+import type { AgregatedBalances, AssetApy, AssetConfig, AssetData, AssetInterest, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, PoolConfig } from '../types/Master';
+import { type HealthParamsArgs, type LiquidationData, type PredictAPYArgs, type PredictHealthFactorArgs, type UserBalance } from '../types/User';
 export declare function mulFactor(decimal: bigint, a: bigint, b: bigint): bigint;
 export declare function mulDiv(x: bigint, y: bigint, z: bigint): bigint;
 export declare function mulDivC(x: bigint, y: bigint, z: bigint): bigint;
@@ -28,8 +28,20 @@ export declare function calculateAssetData(assetsConfigDict: ExtendedAssetsConfi
 export declare function calculateAssetInterest(assetConfig: AssetConfig, assetData: AssetData, masterConstants: MasterConstants): AssetInterest;
 export declare function calculateInterestWithSupplyBorrow(totalSupply: bigint, totalBorrow: bigint, assetConfig: AssetConfig, masterConstants: MasterConstants): AssetInterest;
 export declare function checkNotInDebtAtAll(principals: Dictionary<bigint, bigint>): boolean;
+export declare function exceedsStandardBorrowLimit(principals: Dictionary<bigint, bigint>, assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants): boolean;
+export declare function determineHeCategory(assetsConfig: ExtendedAssetsConfig, principals: Dictionary<bigint, bigint>, poolConfig?: PoolConfig): number;
+export declare function calculateRepayToExitEMode(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, poolConfig: PoolConfig): {
+    activeHeCategory: number;
+    requiredRepayInUsd: bigint;
+    repayAmounts: Dictionary<bigint, bigint>;
+    enoughPriceData: boolean;
+};
+export declare function getAvailableToBorrowWithEMode(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants, poolConfig?: PoolConfig): {
+    availableToBorrow: bigint;
+    heCategory: number;
+};
 export declare function getAgregatedBalances(assetsData: ExtendedAssetsData, assetsConfig: ExtendedAssetsConfig, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants): AgregatedBalances;
-export declare function calculateMaximumWithdrawAmount(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants, assetId: bigint): bigint;
+export declare function calculateMaximumWithdrawAmount(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, poolConfig: PoolConfig, assetId: bigint): bigint;
 export declare function getAvailableToBorrow(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants): bigint;
 /**
  * Calculates balance value for asset principal.
@@ -47,6 +59,7 @@ export declare function calculateHealthParams(parameters: HealthParamsArgs): {
     totalDebt: bigint;
     totalLimit: bigint;
     totalSupply: bigint;
+    activeHeCategory: number;
     isLiquidatable: boolean;
     isBadDebt: (liquidationBonus: bigint) => boolean;
 };

package/dist/api/math.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.predictAPY = exports.predictHealthFactor = exports.calculateLiquidationData = exports.calculateHealthParams = exports.presentValue = exports.getAvailableToBorrow = exports.calculateMaximumWithdrawAmount = exports.getAgregatedBalances = exports.checkNotInDebtAtAll = exports.calculateInterestWithSupplyBorrow = exports.calculateAssetInterest = exports.calculateAssetData = exports.calculateCurrentRates = exports.getAssetLiquidityMinusReserves = exports.calculatePresentValue = exports.BigMath = exports.bigIntMin = exports.bigIntMax = exports.bigAbs = exports.mulDivC = exports.mulDiv = exports.mulFactor = void 0;
+exports.predictAPY = exports.predictHealthFactor = exports.calculateLiquidationData = exports.calculateHealthParams = exports.presentValue = exports.getAvailableToBorrow = exports.calculateMaximumWithdrawAmount = exports.getAgregatedBalances = exports.getAvailableToBorrowWithEMode = exports.calculateRepayToExitEMode = exports.determineHeCategory = exports.exceedsStandardBorrowLimit = exports.checkNotInDebtAtAll = exports.calculateInterestWithSupplyBorrow = exports.calculateAssetInterest = exports.calculateAssetData = exports.calculateCurrentRates = exports.getAssetLiquidityMinusReserves = exports.calculatePresentValue = exports.BigMath = exports.bigIntMin = exports.bigIntMax = exports.bigAbs = exports.mulDivC = exports.mulDiv = exports.mulFactor = void 0;
+const core_1 = require("@ton/core");
 const assets_1 = require("../constants/assets");
 const User_1 = require("../types/User");
 const liquidation_1 = require("./liquidation");
@@ -119,6 +120,222 @@ function checkNotInDebtAtAll(principals) {
     return principals.values().every((x) => x >= 0n);
 }
 exports.checkNotInDebtAtAll = checkNotInDebtAtAll;
+function exceedsStandardBorrowLimit(principals, assetsConfig, assetsData, prices, masterConstants) {
+    let standardBorrowLimit = 0n;
+    let totalBorrow = 0n;
+    for (const [assetId, principal] of principals) {
+        if (principal === 0n)
+            continue;
+        const assetConfig = assetsConfig.get(assetId);
+        const assetData = assetsData.get(assetId);
+        if (!assetConfig || !assetData || !prices.has(assetId))
+            continue;
+        const price = prices.get(assetId);
+        const assetBalance = presentValue(assetData.sRate, assetData.bRate, principal, masterConstants);
+        const assetWorth = (assetBalance.amount * price) / 10n ** assetConfig.decimals;
+        if (assetBalance.type === User_1.BalanceType.supply) {
+            standardBorrowLimit += (assetWorth * assetConfig.collateralFactor) / masterConstants.ASSET_COEFFICIENT_SCALE;
+        }
+        else if (assetBalance.type === User_1.BalanceType.borrow && assetConfig.dust < assetBalance.amount) {
+            totalBorrow += assetWorth;
+        }
+    }
+    return totalBorrow > standardBorrowLimit;
+}
+exports.exceedsStandardBorrowLimit = exceedsStandardBorrowLimit;
+function determineHeCategory(assetsConfig, principals, poolConfig) {
+    const heCategoryByAssetId = new Map();
+    if (poolConfig) {
+        for (const heConfig of poolConfig.poolAssetsHEConfig) {
+            for (const asset of heConfig.assets) {
+                heCategoryByAssetId.set(asset.assetId, heConfig.heCategory);
+            }
+        }
+    }
+    let heCategory = -1;
+    for (const [assetID, principal] of principals) {
+        if (principal >= 0n) {
+            continue;
+        }
+        const heCategoryForAsset = heCategoryByAssetId.get(assetID) ?? assetsConfig.get(assetID)?.heCategory ?? 0;
+        if (heCategoryForAsset <= 0) {
+            return -1;
+        }
+        if (heCategory === -1) {
+            heCategory = heCategoryForAsset;
+            continue;
+        }
+        if (heCategory !== heCategoryForAsset) {
+            return -1;
+        }
+    }
+    return heCategory > 0 ? heCategory : -1;
+}
+exports.determineHeCategory = determineHeCategory;
+function calculateRepayToExitEMode(assetsConfig, assetsData, principals, prices, poolConfig) {
+    const repayAmounts = core_1.Dictionary.empty();
+    const heCategoryRaw = determineHeCategory(assetsConfig, principals, poolConfig);
+    const activeHeCategory = heCategoryRaw > 0 && exceedsStandardBorrowLimit(principals, assetsConfig, assetsData, prices, poolConfig.masterConstants)
+        ? heCategoryRaw
+        : -1;
+    if (activeHeCategory <= 0) {
+        return { activeHeCategory: -1, requiredRepayInUsd: 0n, repayAmounts, enoughPriceData: true };
+    }
+    const availableToBorrowStandard = getAvailableToBorrow(assetsConfig, assetsData, principals, prices, poolConfig.masterConstants);
+    const requiredRepayInUsd = bigIntMax(0n, -availableToBorrowStandard);
+    if (requiredRepayInUsd === 0n) {
+        return {
+            activeHeCategory,
+            requiredRepayInUsd,
+            repayAmounts,
+            enoughPriceData: true,
+        };
+    }
+    let totalDebtWorth = 0n;
+    const debtEntries = [];
+    for (const [assetID, principal] of principals) {
+        if (principal >= 0n) {
+            continue;
+        }
+        if (!prices.has(assetID)) {
+            return {
+                activeHeCategory,
+                requiredRepayInUsd,
+                repayAmounts: core_1.Dictionary.empty(),
+                enoughPriceData: false,
+            };
+        }
+        const assetConfig = assetsConfig.get(assetID);
+        const assetData = assetsData.get(assetID);
+        if (!assetData || !assetConfig) {
+            continue;
+        }
+        const price = prices.get(assetID);
+        const debtAmount = calculatePresentValue(assetData.bRate, -principal, poolConfig.masterConstants);
+        const debtWorth = mulDiv(debtAmount, price, 10n ** assetConfig.decimals);
+        totalDebtWorth += debtWorth;
+        debtEntries.push({ assetID, debtAmount, debtWorth, decimals: assetConfig.decimals, price });
+    }
+    if (totalDebtWorth === 0n) {
+        return {
+            activeHeCategory,
+            requiredRepayInUsd,
+            repayAmounts,
+            enoughPriceData: true,
+        };
+    }
+    let distributedRepayWorth = 0n;
+    debtEntries.forEach((entry, index) => {
+        const repayWorth = index === debtEntries.length - 1
+            ? requiredRepayInUsd - distributedRepayWorth
+            : mulDiv(requiredRepayInUsd, entry.debtWorth, totalDebtWorth);
+        distributedRepayWorth += repayWorth;
+        const repayAmount = bigIntMin(entry.debtAmount, mulDivC(repayWorth, 10n ** entry.decimals, entry.price));
+        if (repayAmount > 0n) {
+            repayAmounts.set(entry.assetID, repayAmount);
+        }
+    });
+    if (distributedRepayWorth < requiredRepayInUsd && debtEntries.length > 0) {
+        const lastEntry = debtEntries[debtEntries.length - 1];
+        const currentRepayAmount = repayAmounts.get(lastEntry.assetID) ?? 0n;
+        if (currentRepayAmount < lastEntry.debtAmount) {
+            repayAmounts.set(lastEntry.assetID, bigIntMin(lastEntry.debtAmount, currentRepayAmount + 1n));
+        }
+    }
+    return {
+        activeHeCategory,
+        requiredRepayInUsd,
+        repayAmounts,
+        enoughPriceData: true,
+    };
+}
+exports.calculateRepayToExitEMode = calculateRepayToExitEMode;
+function getAvailableToBorrowWithEMode(assetsConfig, assetsData, principals, prices, masterConstants, poolConfig) {
+    const heCategoryByAssetId = new Map();
+    if (poolConfig) {
+        for (const heConfig of poolConfig.poolAssetsHEConfig) {
+            for (const asset of heConfig.assets) {
+                heCategoryByAssetId.set(asset.assetId, heConfig.heCategory);
+            }
+        }
+    }
+    const calculateForHeCategory = (heCategory) => {
+        let borrowLimit = 0n;
+        let borrowAmount = 0n;
+        for (const assetID of principals.keys()) {
+            const principal = principals.get(assetID);
+            if (principal == 0n) {
+                continue;
+            }
+            if (!prices.has(assetID)) {
+                return 0n;
+            }
+            const assetConfig = assetsConfig.get(assetID);
+            const assetData = assetsData.get(assetID);
+            const price = prices.get(assetID);
+            if (principal < 0n) {
+                borrowAmount += mulDivC(calculatePresentValue(assetData.bRate, -principal, masterConstants), price, 10n ** assetConfig.decimals);
+            }
+            else {
+                const suppliedAssetInDollars = mulDiv(calculatePresentValue(assetData.sRate, principal, masterConstants), price, 10n ** assetConfig.decimals);
+                const heCategoryForAsset = heCategoryByAssetId.get(assetID) ?? assetConfig.heCategory;
+                const collateralFactor = heCategory > 0 && heCategoryForAsset === heCategory
+                    ? assetConfig.heCollateralFactor
+                    : assetConfig.collateralFactor;
+                borrowLimit += mulDiv(suppliedAssetInDollars, collateralFactor, masterConstants.ASSET_COEFFICIENT_SCALE);
+            }
+        }
+        return borrowLimit - borrowAmount;
+    };
+    const activeHeCategory = determineHeCategory(assetsConfig, principals, poolConfig);
+    if (activeHeCategory > 0) {
+        return {
+            availableToBorrow: calculateForHeCategory(activeHeCategory),
+            heCategory: activeHeCategory,
+        };
+    }
+    const availableToBorrowWithoutEmode = calculateForHeCategory(0);
+    if (!checkNotInDebtAtAll(principals)) {
+        return {
+            availableToBorrow: availableToBorrowWithoutEmode,
+            heCategory: 0,
+        };
+    }
+    const availableHeCategories = new Set();
+    if (poolConfig && poolConfig.poolAssetsHEConfig.length > 0) {
+        for (const heConfig of poolConfig.poolAssetsHEConfig) {
+            const hasSupplyInCategory = heConfig.assets.some((asset) => (principals.get(asset.assetId) ?? 0n) > 0n);
+            if (hasSupplyInCategory && heConfig.heCategory > 0) {
+                availableHeCategories.add(heConfig.heCategory);
+            }
+        }
+    }
+    else {
+        for (const [assetID, principal] of principals) {
+            if (principal <= 0n) {
+                continue;
+            }
+            const heCategory = assetsConfig.get(assetID).heCategory;
+            if (heCategory > 0) {
+                availableHeCategories.add(heCategory);
+            }
+        }
+    }
+    let bestHeCategory = 0;
+    let bestAvailableToBorrow = availableToBorrowWithoutEmode;
+    for (const heCategory of availableHeCategories) {
+        const availableToBorrow = calculateForHeCategory(heCategory);
+        if (availableToBorrow > bestAvailableToBorrow) {
+            bestAvailableToBorrow = availableToBorrow;
+            bestHeCategory = heCategory;
+        }
+    }
+    return {
+        availableToBorrow: bestAvailableToBorrow,
+        heCategory: bestHeCategory,
+    };
+}
+exports.getAvailableToBorrowWithEMode = getAvailableToBorrowWithEMode;
 function getAgregatedBalances(assetsData, assetsConfig, principals, prices, masterConstants) {
     let user_total_supply = 0n;
     let user_total_borrow = 0n;
@@ -145,13 +362,13 @@ function getAgregatedBalances(assetsData, assetsConfig, principals, prices, mast
     return { totalSupply: user_total_supply, totalBorrow: user_total_borrow };
 }
 exports.getAgregatedBalances = getAgregatedBalances;
-function calculateMaximumWithdrawAmount(assetsConfig, assetsData, principals, prices, masterConstants, assetId) {
+function calculateMaximumWithdrawAmount(assetsConfig, assetsData, principals, prices, poolConfig, assetId) {
     let withdrawAmountMax = 0n;
     const assetConfig = assetsConfig.get(assetId);
     const assetData = assetsData.get(assetId);
     const oldPrincipal = principals.get(assetId);
     if (oldPrincipal > assetConfig.dust) {
-        const oldPresentValue = presentValue(assetData.sRate, assetData.bRate, oldPrincipal, masterConstants);
+        const oldPresentValue = presentValue(assetData.sRate, assetData.bRate, oldPrincipal, poolConfig.masterConstants);
         if (checkNotInDebtAtAll(principals)) {
             withdrawAmountMax = oldPresentValue.amount;
         }
@@ -159,15 +376,19 @@ function calculateMaximumWithdrawAmount(assetsConfig, assetsData, principals, pr
             if (!prices.has(assetId)) {
                 return 0n;
             }
-            const borrowable = getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants);
+            const borrowable = getAvailableToBorrow(assetsConfig, assetsData, principals, prices, poolConfig.masterConstants);
             const price = prices.get(assetId);
             let maxAmountToReclaim = 0n;
             if (assetConfig.collateralFactor == 0n) {
                 maxAmountToReclaim = oldPresentValue.amount;
             }
             else if (price > 0) {
-                maxAmountToReclaim = bigIntMax(0n, mulDiv(mulDiv(borrowable, masterConstants.ASSET_COEFFICIENT_SCALE, assetConfig.collateralFactor), 10n ** assetConfig.decimals, price) -
-                    calculatePresentValue(assetData.sRate, assetConfig.dust, masterConstants) / 2n);
+                const { availableToBorrow: borrowable, heCategory } = getAvailableToBorrowWithEMode(assetsConfig, assetsData, principals, prices, poolConfig.masterConstants, poolConfig);
+                const collateralFactor = heCategory > 0 && assetConfig.heCategory === heCategory
+                    ? assetConfig.heCollateralFactor
+                    : assetConfig.collateralFactor;
+                maxAmountToReclaim = bigIntMax(0n, mulDiv(mulDiv(borrowable, poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE, collateralFactor), 10n ** assetConfig.decimals, price) -
+                    calculatePresentValue(assetData.sRate, assetConfig.dust, poolConfig.masterConstants) / 2n);
             }
             withdrawAmountMax = bigIntMin(maxAmountToReclaim, oldPresentValue.amount);
         }
@@ -177,7 +398,7 @@ function calculateMaximumWithdrawAmount(assetsConfig, assetsData, principals, pr
             return 0n;
         }
         const price = prices.get(assetId);
-        return ((getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants) *
+        return ((getAvailableToBorrowWithEMode(assetsConfig, assetsData, principals, prices, poolConfig.masterConstants, poolConfig).availableToBorrow *
             10n ** assetConfig.decimals) /
             price);
     }
@@ -243,9 +464,13 @@ exports.presentValue = presentValue;
 function calculateHealthParams(parameters) {
     const { principals, prices, assetsData, assetsConfig, poolConfig } = parameters;
     const { ASSET_LIQUIDATION_THRESHOLD_SCALE } = poolConfig.masterConstants;
+    let activeHeCategory = determineHeCategory(assetsConfig, principals, poolConfig);
     let totalSupply = 0n;
     let totalDebt = 0n;
     let totalLimit = 0n;
+    if (activeHeCategory > 0 && !exceedsStandardBorrowLimit(principals, assetsConfig, assetsData, prices, poolConfig.masterConstants)) {
+        activeHeCategory = -1;
+    }
     for (const asset of poolConfig.poolAssetsConfig) {
         if (!principals.has(asset.assetId))
             continue;
@@ -264,8 +489,11 @@ function calculateHealthParams(parameters) {
         const assetBalance = presentValue(sRate, bRate, assetPrincipal, poolConfig.masterConstants);
         const assetWorth = (assetBalance.amount * assetPrice) / assetScale;
         if (assetBalance.type === User_1.BalanceType.supply) {
+            const liquidationThreshold = activeHeCategory > 0 && assetConfig.heCategory === activeHeCategory
+                ? assetConfig.heLiquidationThreshold
+                : assetConfig.liquidationThreshold;
             totalSupply += assetWorth;
-            totalLimit += (assetWorth * assetConfig.liquidationThreshold) / ASSET_LIQUIDATION_THRESHOLD_SCALE;
+            totalLimit += (assetWorth * liquidationThreshold) / ASSET_LIQUIDATION_THRESHOLD_SCALE;
         }
         else if (assetBalance.type === User_1.BalanceType.borrow && assetConfig.dust < assetBalance.amount) {
             totalDebt += assetWorth;
@@ -281,6 +509,7 @@ function calculateHealthParams(parameters) {
         totalDebt,
         totalLimit,
         totalSupply,
+        activeHeCategory,
         isLiquidatable: _isLiquidable,
         isBadDebt: _isBadDebt,
     };
@@ -302,6 +531,10 @@ function calculateLiquidationData(assetsConfig, assetsData, principals, prices,
     let loanAsset = assets_1.UNDEFINED_ASSET;
     let totalDebt = 0n;
     let totalLimit = 0n;
+    let activeHeCategory = determineHeCategory(assetsConfig, principals, poolConfig);
+    if (activeHeCategory > 0 && !exceedsStandardBorrowLimit(principals, assetsConfig, assetsData, prices, poolConfig.masterConstants)) {
+        activeHeCategory = -1;
+    }
     const { ASSET_SRATE_SCALE, ASSET_BRATE_SCALE, COLLATERAL_WORTH_THRESHOLD } = poolConfig.masterConstants;
     for (const asset of poolConfig.poolAssetsConfig) {
         const principal = principals.get(asset.assetId);
@@ -314,8 +547,10 @@ function calculateLiquidationData(assetsConfig, assetsData, principals, prices,
             : (principal * assetData.bRate) / ASSET_BRATE_SCALE;
         const assetWorth = (bigAbs(balance) * prices.get(asset.assetId)) / 10n ** assetConfig.decimals;
         if (balance > 0) {
-            totalLimit +=
-                (assetWorth * assetConfig.liquidationThreshold) / poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE;
+            const liquidationThreshold = activeHeCategory > 0 && assetConfig.heCategory === activeHeCategory
+                ? assetConfig.heLiquidationThreshold
+                : assetConfig.liquidationThreshold;
+            totalLimit += (assetWorth * liquidationThreshold) / poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE;
             // get the greatest collateral
             if (assetWorth > collateralValue) {
                 collateralValue = assetWorth;
@@ -380,42 +615,130 @@ function calculateLiquidationData(assetsConfig, assetsData, principals, prices,
 }
 exports.calculateLiquidationData = calculateLiquidationData;
 function predictHealthFactor(args) {
-    const healthParams = calculateHealthParams(args);
+    const { principals, prices, assetsData, assetsConfig, poolConfig } = args;
     const assetId = args.asset.assetId;
-    const assetConfig = args.assetsConfig.get(assetId);
-    const assetPrice = Number(args.prices.get(assetId));
-    let totalLimit = Number(healthParams.totalLimit);
-    let totalBorrow = Number(healthParams.totalDebt);
-    const currentAmount = args.amount;
-    const decimals = Number(assetConfig.decimals);
-    const currentBalance = (assetPrice * Number(currentAmount)) / Math.pow(10, decimals);
     const changeType = args.balanceChangeType;
+    const currentAmount = args.amount;
+    const heCategoryByAssetId = new Map();
+    for (const heConfig of poolConfig.poolAssetsHEConfig) {
+        for (const asset of heConfig.assets) {
+            heCategoryByAssetId.set(asset.assetId, heConfig.heCategory);
+        }
+    }
+    const projectedBalances = new Map();
+    for (const asset of poolConfig.poolAssetsConfig) {
+        if (!principals.has(asset.assetId)) {
+            continue;
+        }
+        const assetPrincipal = principals.get(asset.assetId);
+        const assetConfig = assetsConfig.get(asset.assetId);
+        const assetData = assetsData.get(asset.assetId);
+        const balance = presentValue(assetData.sRate, assetData.bRate, assetPrincipal, poolConfig.masterConstants);
+        if (balance.type === User_1.BalanceType.supply) {
+            projectedBalances.set(asset.assetId, balance.amount);
+        }
+        else if (balance.type === User_1.BalanceType.borrow) {
+            projectedBalances.set(asset.assetId, -balance.amount);
+        }
+    }
     if (currentAmount != null && currentAmount != 0n) {
+        const currentSignedBalance = projectedBalances.get(assetId) ?? 0n;
+        const actionAssetConfig = assetsConfig.get(assetId);
+        let newSignedBalance = currentSignedBalance;
         if (changeType == User_1.BalanceChangeType.Borrow) {
-            totalBorrow +=
-                currentBalance *
-                    (1 +
-                        Number(assetConfig.originationFee) /
-                            Number(args.poolConfig.masterConstants.ASSET_ORIGINATION_FEE_SCALE));
+            const borrowWithFee = currentAmount +
+                mulDivC(currentAmount, actionAssetConfig.originationFee, poolConfig.masterConstants.ASSET_ORIGINATION_FEE_SCALE);
+            newSignedBalance -= borrowWithFee;
         }
         else if (changeType == User_1.BalanceChangeType.Repay) {
-            totalBorrow -= currentBalance;
+            newSignedBalance += currentAmount;
         }
         else if (changeType == User_1.BalanceChangeType.Withdraw) {
-            totalLimit -=
-                (currentBalance * Number(assetConfig.liquidationThreshold)) /
-                    Number(args.poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE);
+            newSignedBalance -= currentAmount;
         }
         else if (changeType == User_1.BalanceChangeType.Supply) {
-            totalLimit +=
-                (currentBalance * Number(assetConfig.liquidationThreshold)) /
-                    Number(args.poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE);
+            newSignedBalance += currentAmount;
         }
+        projectedBalances.set(assetId, newSignedBalance);
     }
-    if (Number(totalLimit) == 0) {
-        return 1;
+    const getHeCategoryForAsset = (assetID, assetConfig) => {
+        return heCategoryByAssetId.get(assetID) ?? assetConfig.heCategory;
+    };
+    let projectedActiveHeCategory = -1;
+    for (const asset of poolConfig.poolAssetsConfig) {
+        const signedBalance = projectedBalances.get(asset.assetId) ?? 0n;
+        if (signedBalance >= 0n) {
+            continue;
+        }
+        const assetConfig = assetsConfig.get(asset.assetId);
+        const heCategory = getHeCategoryForAsset(asset.assetId, assetConfig);
+        if (heCategory <= 0) {
+            projectedActiveHeCategory = -1;
+            break;
+        }
+        if (projectedActiveHeCategory === -1) {
+            projectedActiveHeCategory = heCategory;
+            continue;
+        }
+        if (projectedActiveHeCategory !== heCategory) {
+            projectedActiveHeCategory = -1;
+            break;
+        }
+    }
+    const calculateProjectedHealthFactor = (heCategoryForCalculation) => {
+        let totalLimit = 0n;
+        let totalBorrow = 0n;
+        for (const asset of poolConfig.poolAssetsConfig) {
+            const signedBalance = projectedBalances.get(asset.assetId) ?? 0n;
+            if (signedBalance === 0n) {
+                continue;
+            }
+            const assetConfig = assetsConfig.get(asset.assetId);
+            const price = prices.get(asset.assetId);
+            const assetWorth = (bigAbs(signedBalance) * price) / 10n ** assetConfig.decimals;
+            if (signedBalance > 0n) {
+                const heCategory = getHeCategoryForAsset(asset.assetId, assetConfig);
+                const liquidationThreshold = heCategoryForCalculation > 0 && heCategory === heCategoryForCalculation
+                    ? assetConfig.heLiquidationThreshold
+                    : assetConfig.liquidationThreshold;
+                totalLimit +=
+                    (assetWorth * liquidationThreshold) / poolConfig.masterConstants.ASSET_LIQUIDATION_THRESHOLD_SCALE;
+                continue;
+            }
+            const borrowAmount = -signedBalance;
+            if (borrowAmount > assetConfig.dust) {
+                totalBorrow += assetWorth;
+            }
+        }
+        if (totalLimit === 0n) {
+            return 1;
+        }
+        return Math.min(Math.max(1 - Number(totalBorrow) / Number(totalLimit), 0), 1);
+    };
+    if (projectedActiveHeCategory > 0) {
+        let standardBorrowLimit = 0n;
+        let projectedTotalBorrow = 0n;
+        for (const asset of poolConfig.poolAssetsConfig) {
+            const signedBalance = projectedBalances.get(asset.assetId) ?? 0n;
+            if (signedBalance === 0n)
+                continue;
+            const assetConfig = assetsConfig.get(asset.assetId);
+            const price = prices.get(asset.assetId);
+            const assetWorth = (bigAbs(signedBalance) * price) / 10n ** assetConfig.decimals;
+            if (signedBalance > 0n) {
+                standardBorrowLimit +=
+                    (assetWorth * assetConfig.collateralFactor) /
+                        poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE;
+            }
+            else if (-signedBalance > assetConfig.dust) {
+                projectedTotalBorrow += assetWorth;
+            }
+        }
+        if (projectedTotalBorrow > standardBorrowLimit) {
+            return calculateProjectedHealthFactor(projectedActiveHeCategory);
+        }
     }
-    return Math.min(Math.max(1 - totalBorrow / totalLimit, 0), 1); // let's limit a result to zero below and one above
+    return calculateProjectedHealthFactor(-1);
 }
 exports.predictHealthFactor = predictHealthFactor;
 /**

package/dist/api/parser.js

@@ -109,8 +109,8 @@ function createAssetConfig() {
             const baseTrackingBorrowSpeed = ref.loadUintBig(64);
             const borrowCap = ref.loadInt(64);
             const heCategory = ref.loadUint(8);
-            const heCollateralFactor = ref.loadUint(16);
-            const heLiquidationThreshold = ref.loadUint(16);
+            const heCollateralFactor = ref.loadUintBig(16);
+            const heLiquidationThreshold = ref.loadUintBig(16);
             return {
                 jwAddress,
                 decimals,
@@ -202,8 +202,8 @@ function parseUserLiteData(userDataBOC, assetsData, assetsConfig, poolConfig, ap
     const masterConstants = poolConfig.masterConstants;
     const userSlice = core_1.Cell.fromBase64(userDataBOC).beginParse();
     const codeVersion = userSlice.loadCoins();
-    const masterAddress = userSlice.loadAddress();
-    const userAddress = userSlice.loadAddress();
+    const masterAddress = userSlice.loadAddressAny();
+    const userAddress = userSlice.loadAddressAny();
     const realPrincipals = userSlice.loadDict(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.BigInt(64));
     const principalsDict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.BigInt(64));
     const userState = userSlice.loadInt(64);
@@ -215,18 +215,27 @@ function parseUserLiteData(userDataBOC, assetsData, assetsConfig, poolConfig, ap
     let backupCell1 = null;
     let backupCell2 = null;
     const bitsLeft = userSlice.remainingBits;
-    if (bitsLeft > 32) {
+    const refsLeft = userSlice.remainingRefs;
+    if (bitsLeft === 0 && refsLeft === 0) {
+        // Init format: no extra data after state
+    }
+    else if (bitsLeft >= 64 + 64 + 32 && refsLeft >= 1) {
+        // Old format with tracking indexes
         trackingSupplyIndex = userSlice.loadUintBig(64);
         trackingBorrowIndex = userSlice.loadUintBig(64);
         dutchAuctionStart = userSlice.loadUint(32);
         backupCell = (0, helpers_1.loadMyRef)(userSlice);
     }
-    else {
+    else if (bitsLeft >= 3 && refsLeft >= 1) {
+        // New format with rewards dict + maybe_refs
         rewards = userSlice.loadDict(core_1.Dictionary.Keys.BigUint(256), createUserRewards());
-        backupCell1 = userSlice.loadMaybeRef();
-        backupCell2 = userSlice.loadMaybeRef();
+        if (userSlice.remainingBits >= 2) {
+            backupCell1 = userSlice.loadMaybeRef();
+            backupCell2 = userSlice.loadMaybeRef();
+        }
     }
-    userSlice.endParse();
+    // Skip remaining data if any (for forward compatibility)
+    // userSlice.endParse();
     const userBalances = core_1.Dictionary.empty();
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetData = assetsData.get(asset.assetId);
@@ -273,6 +282,7 @@ function parseUserData(userLiteData, assetsData, assetsConfig, prices, poolConfi
     const masterConstants = poolConfig.masterConstants;
     const withdrawalLimits = core_1.Dictionary.empty();
     const borrowLimits = core_1.Dictionary.empty();
+    const borrowLimitsWithEmode = core_1.Dictionary.empty();
     let supplyBalance = 0n;
     let borrowBalance = 0n;
     for (const [assetId, principal] of userLiteData.realPrincipals) {
@@ -308,24 +318,32 @@ function parseUserData(userLiteData, assetsData, assetsConfig, prices, poolConfi
         }
     }
     const availableToBorrow = (0, math_1.getAvailableToBorrow)(assetsConfig, assetsData, userLiteData.realPrincipals, prices, masterConstants);
+    const { availableToBorrow: availableToBorrowWithEmode, heCategory: predictedHeCategory } = (0, math_1.getAvailableToBorrowWithEMode)(assetsConfig, assetsData, userLiteData.realPrincipals, prices, masterConstants, poolConfig);
+    let activeHeCategory = (0, math_1.determineHeCategory)(assetsConfig, userLiteData.realPrincipals, poolConfig);
+    if (activeHeCategory > 0 && !(0, math_1.exceedsStandardBorrowLimit)(userLiteData.realPrincipals, assetsConfig, assetsData, prices, masterConstants)) {
+        activeHeCategory = -1;
+    }
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const balance = userLiteData.balances.get(asset.assetId);
         const assetConfig = assetsConfig.get(asset.assetId);
         const assetData = assetsData.get(asset.assetId);
         const assetLiquidityMinusReserves = (0, math_1.getAssetLiquidityMinusReserves)(assetData, masterConstants);
         if (balance.type === User_1.BalanceType.supply) {
-            withdrawalLimits.set(asset.assetId, (0, math_1.bigIntMin)((0, math_1.calculateMaximumWithdrawAmount)(assetsConfig, assetsData, userLiteData.realPrincipals, prices, masterConstants, asset.assetId), assetData.balance));
+            withdrawalLimits.set(asset.assetId, (0, math_1.bigIntMin)((0, math_1.calculateMaximumWithdrawAmount)(assetsConfig, assetsData, userLiteData.realPrincipals, prices, poolConfig, asset.assetId), assetData.balance));
         }
         if (!prices.has(asset.assetId)) {
             borrowLimits.set(asset.assetId, 0n);
+            borrowLimitsWithEmode.set(asset.assetId, 0n);
             continue;
         }
         borrowLimits.set(asset.assetId, (0, math_1.bigIntMax)(0n, (0, math_1.bigIntMin)((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(asset.assetId), assetLiquidityMinusReserves)));
+        borrowLimitsWithEmode.set(asset.assetId, (0, math_1.bigIntMax)(0n, (0, math_1.bigIntMin)((availableToBorrowWithEmode * 10n ** assetConfig.decimals) / prices.get(asset.assetId), assetLiquidityMinusReserves)));
     }
-    const limitUsed = borrowBalance + availableToBorrow;
+    const limitUsed = borrowBalance + availableToBorrowWithEmode;
     const limitUsedPercent = limitUsed === 0n
         ? 0
-        : Number(BigInt(1e9) - (availableToBorrow * BigInt(1e9)) / (borrowBalance + availableToBorrow)) / 1e7;
+        : Number(BigInt(1e9) -
+            (availableToBorrowWithEmode * BigInt(1e9)) / (borrowBalance + availableToBorrowWithEmode)) / 1e7;
     let healthFactor = 1;
     let liquidationData;
     if (!havePrincipalWithoutPrice) {
@@ -338,14 +356,18 @@ function parseUserData(userLiteData, assetsData, assetsConfig, prices, poolConfi
         ...userLiteData,
         withdrawalLimits: withdrawalLimits,
         borrowLimits: borrowLimits,
+        borrowLimitsWithEmode: borrowLimitsWithEmode,
         supplyBalance: supplyBalance,
         borrowBalance: borrowBalance,
         availableToBorrow: availableToBorrow,
+        availableToBorrowWithEmode: availableToBorrowWithEmode,
+        predictedHeCategory: predictedHeCategory,
         limitUsedPercent: limitUsedPercent,
         limitUsed: limitUsed,
         liquidationData: liquidationData,
         healthFactor: healthFactor,
         havePrincipalWithoutPrice: havePrincipalWithoutPrice,
+        activeHeCategory: activeHeCategory,
     };
 }
 exports.parseUserData = parseUserData;

package/dist/constants/assets/assetId.d.ts

@@ -19,6 +19,8 @@ export declare const ASSET_ID: {
     STON: bigint;
     PT_tsUSDe_01Sep2025: bigint;
     PT_tsUSDe_18Dec2025: bigint;
+    TUSDT: bigint;
+    TUSDe: bigint;
     EUSDT: bigint;
     EUSDC: bigint;
 };

package/dist/constants/assets/assetId.js

@@ -27,6 +27,9 @@ exports.ASSET_ID = {
     // STABLE
     PT_tsUSDe_01Sep2025: (0, sha256BigInt_1.sha256Hash)('PT_tsUSDe_01Sep2025'),
     PT_tsUSDe_18Dec2025: (0, sha256BigInt_1.sha256Hash)('PT_tsUSDe_18Dec2025'),
+    // Mainnet test assets
+    TUSDT: (0, sha256BigInt_1.sha256Hash)('TUSDT'),
+    TUSDe: (0, sha256BigInt_1.sha256Hash)('TUSDe'),
     // Testnet assets, faucet t.me/evaabuidl
     EUSDT: (0, sha256BigInt_1.sha256Hash)('EUSDT'),
     EUSDC: (0, sha256BigInt_1.sha256Hash)('EUSDC'),