@evaafi/sdk 0.5.4 → 0.5.6

package/dist/api/helpers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadMaybeMyRef = exports.loadMyRef = void 0;
+exports.loadMyRef = loadMyRef;
+exports.loadMaybeMyRef = loadMaybeMyRef;
 const core_1 = require("@ton/core");
 class MyCell extends core_1.Cell {
     toString() {
@@ -18,7 +19,6 @@ function loadMyRef(slice) {
         refs: cell.refs,
     });
 }
-exports.loadMyRef = loadMyRef;
 function loadMaybeMyRef(slice) {
     const cell = slice.loadMaybeRef();
     if (cell === null) {
@@ -30,4 +30,3 @@ function loadMaybeMyRef(slice) {
         refs: cell.refs,
     });
 }
-exports.loadMaybeMyRef = loadMaybeMyRef;

package/dist/api/math.d.ts

@@ -1,8 +1,9 @@
-import { AssetConfig, AssetData, AssetInterest, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants } from '../types/Master';
+import { AgregatedBalances, AssetConfig, AssetData, AssetInterest, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, PoolConfig } from '../types/Master';
 import { Dictionary } from '@ton/core';
 import { LiquidationData, PredictHealthFactorArgs, 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;
 export declare function bigIntMax(...args: bigint[]): bigint;
 export declare function bigIntMin(...args: bigint[]): bigint;
 export declare function calculatePresentValue(index: bigint, principalValue: bigint, masterConstants: MasterConstants): bigint;
@@ -15,7 +16,28 @@ export declare function calculateCurrentRates(assetConfig: AssetConfig, assetDat
 };
 export declare function calculateAssetData(assetsConfigDict: ExtendedAssetsConfig, assetsDataDict: Dictionary<bigint, AssetData>, assetId: bigint, masterConstants: MasterConstants): ExtendedAssetData;
 export declare function calculateAssetInterest(assetConfig: AssetConfig, assetData: AssetData, masterConstants: MasterConstants): AssetInterest;
+export declare function checkNotInDebtAtAll(principals: Dictionary<bigint, bigint>): boolean;
+export declare function getAgregatedBalances(assetsData: ExtendedAssetsData, assetsConfig: ExtendedAssetsConfig, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants): AgregatedBalances;
+/**
+ * @deprecated The method should be used only for main contract v5
+ */
+export declare function isV5MainPoolContract(poolConfig: PoolConfig): boolean;
+/**
+ * @deprecated The method should be used only for main contract v5
+ */
+export declare function calculateMaximumWithdrawAmountOld(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants, assetId: bigint): bigint;
+export declare function calculateMaximumWithdrawAmount(//  todo v6 ifelse dust not debt at all is fixed?
+assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants, assetId: bigint): bigint;
 export declare function getAvailableToBorrow(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants): bigint;
 export declare function presentValue(sRate: bigint, bRate: bigint, principalValue: bigint, masterConstants: MasterConstants): UserBalance;
-export declare function calculateLiquidationData(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants): LiquidationData;
+/**
+ *
+ * @param assetsConfig
+ * @param assetsData
+ * @param principals
+ * @param prices
+ * @param poolConfig
+ * @returns can return UNDEFINED_ASSET if there are no assets
+ */
+export declare function calculateLiquidationData(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, poolConfig: PoolConfig): LiquidationData;
 export declare function predictHealthFactor(args: PredictHealthFactorArgs): number;

package/dist/api/math.js

@@ -1,28 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.predictHealthFactor = exports.calculateLiquidationData = exports.presentValue = exports.getAvailableToBorrow = exports.calculateAssetInterest = exports.calculateAssetData = exports.calculateCurrentRates = exports.calculatePresentValue = exports.bigIntMin = exports.bigIntMax = exports.mulDiv = exports.mulFactor = void 0;
+exports.mulFactor = mulFactor;
+exports.mulDiv = mulDiv;
+exports.mulDivC = mulDivC;
+exports.bigIntMax = bigIntMax;
+exports.bigIntMin = bigIntMin;
+exports.calculatePresentValue = calculatePresentValue;
+exports.calculateCurrentRates = calculateCurrentRates;
+exports.calculateAssetData = calculateAssetData;
+exports.calculateAssetInterest = calculateAssetInterest;
+exports.checkNotInDebtAtAll = checkNotInDebtAtAll;
+exports.getAgregatedBalances = getAgregatedBalances;
+exports.isV5MainPoolContract = isV5MainPoolContract;
+exports.calculateMaximumWithdrawAmountOld = calculateMaximumWithdrawAmountOld;
+exports.calculateMaximumWithdrawAmount = calculateMaximumWithdrawAmount;
+exports.getAvailableToBorrow = getAvailableToBorrow;
+exports.presentValue = presentValue;
+exports.calculateLiquidationData = calculateLiquidationData;
+exports.predictHealthFactor = predictHealthFactor;
 const User_1 = require("../types/User");
 const sha256BigInt_1 = require("../utils/sha256BigInt");
+const assets_1 = require("../constants/assets");
+const __1 = require("..");
 function mulFactor(decimal, a, b) {
     return (a * b) / decimal;
 }
-exports.mulFactor = mulFactor;
 function mulDiv(x, y, z) {
     return (x * y) / z;
 }
-exports.mulDiv = mulDiv;
+function mulDivC(x, y, z) {
+    const mul = x * y;
+    return mul / z + (mul % z ? 1n : 0n);
+}
 function bigIntMax(...args) {
     return args.reduce((m, e) => (e > m ? e : m));
 }
-exports.bigIntMax = bigIntMax;
 function bigIntMin(...args) {
     return args.reduce((m, e) => (e < m ? e : m));
 }
-exports.bigIntMin = bigIntMin;
 function calculatePresentValue(index, principalValue, masterConstants) {
     return (principalValue * index) / masterConstants.FACTOR_SCALE;
 }
-exports.calculatePresentValue = calculatePresentValue;
 function calculateCurrentRates(assetConfig, assetData, masterConstants) {
     const now = BigInt(Math.floor(Date.now() / 1000));
     const timeElapsed = now - assetData.lastAccural;
@@ -46,7 +64,6 @@ function calculateCurrentRates(assetConfig, assetData, masterConstants) {
         now,
     };
 }
-exports.calculateCurrentRates = calculateCurrentRates;
 function calculateAssetData(assetsConfigDict, assetsDataDict, assetId, masterConstants) {
     const config = assetsConfigDict.get(assetId);
     const data = assetsDataDict.get(assetId);
@@ -65,7 +82,6 @@ function calculateAssetData(assetsConfigDict, assetsDataDict, assetId, masterCon
         ...{ supplyApy, borrowApy },
     };
 }
-exports.calculateAssetData = calculateAssetData;
 function calculateAssetInterest(assetConfig, assetData, masterConstants) {
     const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply, masterConstants);
     const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow, masterConstants);
@@ -92,7 +108,112 @@ function calculateAssetInterest(assetConfig, assetData, masterConstants) {
         borrowInterest,
     };
 }
-exports.calculateAssetInterest = calculateAssetInterest;
+function checkNotInDebtAtAll(principals) {
+    return principals.values().every(x => x >= 0n);
+}
+function getAgregatedBalances(assetsData, assetsConfig, principals, prices, masterConstants) {
+    let user_total_supply = 0n;
+    let user_total_borrow = 0n;
+    for (const [assetId, principal] of principals) {
+        if (principal) {
+            if (!prices.has(assetId)) {
+                return { totalSupply: 0n, totalBorrow: 0n };
+            }
+            const price = prices.get(assetId);
+            const assetData = assetsData.get(assetId);
+            const assetConfig = assetsConfig.get(assetId);
+            if (principal < 0) {
+                user_total_borrow += presentValue(assetData.sRate, assetData.bRate, principal, masterConstants).amount * price / 10n ** assetConfig.decimals;
+            }
+            else {
+                user_total_supply += presentValue(assetData.sRate, assetData.bRate, principal, masterConstants).amount * price / 10n ** assetConfig.decimals;
+            }
+        }
+    }
+    return { totalSupply: user_total_supply, totalBorrow: user_total_borrow };
+}
+/**
+ * @deprecated The method should be used only for main contract v5
+ */
+function isV5MainPoolContract(poolConfig) {
+    if ((poolConfig.masterAddress == __1.MAINNET_POOL_CONFIG.masterAddress && poolConfig.masterVersion == 5) ||
+        (poolConfig.masterAddress == __1.TESTNET_POOL_CONFIG.masterAddress && poolConfig.masterVersion == 5)) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * @deprecated The method should be used only for main contract v5
+ */
+function calculateMaximumWithdrawAmountOld(assetsConfig, assetsData, principals, prices, masterConstants, assetId) {
+    let withdrawAmountMax = 0n;
+    const assetConfig = assetsConfig.get(assetId);
+    const assetData = assetsData.get(assetId);
+    const oldPrincipal = principals.get(assetId);
+    const oldPresentValue = presentValue(assetData.sRate, assetData.bRate, oldPrincipal, masterConstants);
+    if (oldPresentValue.amount > assetConfig.dust) {
+        if (checkNotInDebtAtAll(principals)) {
+            withdrawAmountMax = oldPresentValue.amount;
+        }
+        else {
+            if (!prices.has(assetId)) {
+                return 0n;
+            }
+            //const borrowable = getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants);
+            const price = prices.get(assetId);
+            const agregatedBalances = getAgregatedBalances(assetsData, assetsConfig, principals, principals, masterConstants);
+            let maxAmountToReclaim = mulDiv(agregatedBalances.totalSupply - mulDivC(agregatedBalances.totalBorrow, masterConstants.ASSET_COEFFICIENT_SCALE, assetConfig.collateralFactor), 10n ** assetConfig.decimals, price);
+            withdrawAmountMax = bigIntMin(maxAmountToReclaim, oldPresentValue.amount);
+        }
+    }
+    else {
+        if (!prices.has(assetId)) {
+            return 0n;
+        }
+        const price = prices.get(assetId);
+        return getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants) * (10n ** assetConfig.decimals) / price;
+    }
+    return withdrawAmountMax;
+}
+function calculateMaximumWithdrawAmount(//  todo v6 ifelse dust not debt at all is fixed?
+assetsConfig, assetsData, principals, prices, masterConstants, 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);
+        if (checkNotInDebtAtAll(principals)) {
+            withdrawAmountMax = oldPresentValue.amount;
+        }
+        else {
+            if (!prices.has(assetId)) {
+                return 0n;
+            }
+            const borrowable = getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants);
+            const price = prices.get(assetId);
+            let maxAmountToReclaim = 0n;
+            if (assetConfig.collateralFactor == 0n) {
+                maxAmountToReclaim = oldPresentValue.amount;
+            }
+            else if (price > 0) {
+                maxAmountToReclaim =
+                    mulDiv(mulDivC(borrowable, masterConstants.ASSET_COEFFICIENT_SCALE, assetConfig.collateralFactor), 10n ** assetConfig.decimals, price);
+            }
+            withdrawAmountMax = bigIntMin(maxAmountToReclaim, oldPresentValue.amount);
+        }
+    }
+    else {
+        if (!prices.has(assetId)) {
+            return 0n;
+        }
+        const price = prices.get(assetId);
+        return getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants) * (10n ** assetConfig.decimals) / price;
+    }
+    return withdrawAmountMax;
+}
 function getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants) {
     let borrowLimit = 0n;
     let borrowAmount = 0n;
@@ -106,14 +227,11 @@ function getAvailableToBorrow(assetsConfig, assetsData, principals, prices, mast
         }
         else if (principal > 0) {
             borrowLimit +=
-                (calculatePresentValue(assetData.sRate, principal, masterConstants) * price * assetConfig.collateralFactor) /
-                    10n ** assetConfig.decimals /
-                    masterConstants.ASSET_COEFFICIENT_SCALE;
+                mulDivC(mulDivC(calculatePresentValue(assetData.sRate, principal, masterConstants), price, 10n ** assetConfig.decimals), assetConfig.collateralFactor, masterConstants.ASSET_COEFFICIENT_SCALE);
         }
     }
     return borrowLimit - borrowAmount;
 }
-exports.getAvailableToBorrow = getAvailableToBorrow;
 function presentValue(sRate, bRate, principalValue, masterConstants) {
     if (principalValue > 0) {
         return {
@@ -134,63 +252,74 @@ function presentValue(sRate, bRate, principalValue, masterConstants) {
         };
     }
 }
-exports.presentValue = presentValue;
-function calculateLiquidationData(assetsConfig, assetsData, principals, prices, masterConstants) {
-    let gCollateralValue = 0n;
-    let gCollateralAsset = 0n;
-    let gLoanValue = 0n;
-    let gLoanAsset = 0n;
+/**
+ *
+ * @param assetsConfig
+ * @param assetsData
+ * @param principals
+ * @param prices
+ * @param poolConfig
+ * @returns can return UNDEFINED_ASSET if there are no assets
+ */
+function calculateLiquidationData(assetsConfig, assetsData, principals, prices, poolConfig) {
+    let collateralValue = 0n;
+    let collateralAsset = assets_1.UNDEFINED_ASSET;
+    let loanValue = 0n;
+    let loanAsset = assets_1.UNDEFINED_ASSET;
     let totalDebt = 0n;
     let totalLimit = 0n;
-    for (const key of principals.keys()) {
-        const principal = principals.get(key);
-        const assetConfig = assetsConfig.get(key);
-        const assetData = assetsData.get(key);
+    for (const asset of poolConfig.poolAssetsConfig) {
+        if (!principals.has(asset.assetId)) {
+            continue;
+        }
+        const principal = principals.get(asset.assetId);
+        const assetConfig = assetsConfig.get(asset.assetId);
+        const assetData = assetsData.get(asset.assetId);
         const balance = principal > 0 ? (principal * assetData.sRate) / BigInt(1e12) : (principal * assetData.bRate) / BigInt(1e12);
         if (balance > 0) {
-            const assetWorth = (balance * prices.get(key)) / 10n ** assetConfig.decimals;
-            totalLimit += (assetWorth * assetConfig.liquidationThreshold) / masterConstants.ASSET_COEFFICIENT_SCALE;
-            if (assetWorth > gCollateralValue) {
-                gCollateralValue = assetWorth;
-                gCollateralAsset = key;
+            const assetWorth = (balance * prices.get(asset.assetId)) / 10n ** assetConfig.decimals;
+            totalLimit += (assetWorth * assetConfig.liquidationThreshold) / poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE;
+            if (assetWorth > collateralValue) {
+                collateralValue = assetWorth;
+                collateralAsset = asset;
             }
         }
         else if (balance < 0) {
-            const assetWorth = (-balance * prices.get(key)) / 10n ** assetConfig.decimals;
+            const assetWorth = (-balance * prices.get(asset.assetId)) / 10n ** assetConfig.decimals;
             totalDebt += assetWorth;
-            if (assetWorth > gLoanValue) {
-                gLoanValue = assetWorth;
-                gLoanAsset = key;
+            if (assetWorth > loanValue) {
+                loanValue = assetWorth;
+                loanAsset = asset;
             }
         }
     }
-    if (totalLimit < totalDebt) {
-        const gLoanAssetPrice = prices.get(gLoanAsset);
+    if (collateralAsset.assetId !== assets_1.UNDEFINED_ASSET.assetId && totalLimit < totalDebt) {
+        const loanAssetPrice = prices.get(loanAsset.assetId);
         const values = [];
-        const gCollateralAssetConfig = assetsConfig.get(gCollateralAsset);
-        const gLoanAssetConfig = assetsConfig.get(gLoanAsset);
-        const liquidationBonus = gCollateralAssetConfig.liquidationBonus;
-        const loanDecimal = 10n ** gLoanAssetConfig.decimals;
-        values.push((bigIntMax(gCollateralValue / 2n, bigIntMin(gCollateralValue, 10000000000n)) *
-            loanDecimal *
-            masterConstants.ASSET_COEFFICIENT_SCALE) /
+        const collateralAssetConfig = assetsConfig.get(collateralAsset.assetId);
+        const loanAssetConfig = assetsConfig.get(loanAsset.assetId);
+        const liquidationBonus = collateralAssetConfig.liquidationBonus;
+        const loanScale = 10n ** loanAssetConfig.decimals;
+        values.push((bigIntMax(collateralValue / 2n, bigIntMin(collateralValue, 100000000000n)) *
+            loanScale *
+            poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE) /
             liquidationBonus /
-            gLoanAssetPrice);
-        values.push((gLoanValue * loanDecimal) / gLoanAssetPrice);
+            loanAssetPrice);
+        values.push((loanValue * loanScale) / loanAssetPrice);
         const liquidationAmount = bigIntMin(...values) - 5n;
-        const gCollateralAssetPrice = prices.get(gCollateralAsset);
-        const collateralDecimal = 10n ** gCollateralAssetConfig.decimals;
-        let minCollateralAmount = (((liquidationAmount * gLoanAssetPrice * liquidationBonus) / 10000n) * collateralDecimal) /
-            gCollateralAssetPrice /
-            loanDecimal -
+        const collateralAssetPrice = prices.get(collateralAsset.assetId);
+        const collateralDecimal = 10n ** collateralAssetConfig.decimals;
+        let minCollateralAmount = (((liquidationAmount * loanAssetPrice * liquidationBonus) / poolConfig.masterConstants.ASSET_LIQUIDATION_BONUS_SCALE) * collateralDecimal) /
+            collateralAssetPrice /
+            loanScale -
             10n;
         minCollateralAmount = (minCollateralAmount * 97n) / 100n;
         if (minCollateralAmount / collateralDecimal >= 1n) {
             return {
-                greatestCollateralAsset: gCollateralAsset,
-                greatestCollateralValue: gCollateralValue,
-                greatestLoanAsset: gLoanAsset,
-                greatestLoanValue: gLoanValue,
+                greatestCollateralAsset: collateralAsset,
+                greatestCollateralValue: collateralValue,
+                greatestLoanAsset: loanAsset,
+                greatestLoanValue: loanValue,
                 totalDebt,
                 totalLimit,
                 liquidable: true,
@@ -200,18 +329,17 @@ function calculateLiquidationData(assetsConfig, assetsData, principals, prices,
         }
     }
     return {
-        greatestCollateralAsset: gCollateralAsset,
-        greatestCollateralValue: gCollateralValue,
-        greatestLoanAsset: gLoanAsset,
-        greatestLoanValue: gLoanValue,
+        greatestCollateralAsset: collateralAsset,
+        greatestCollateralValue: collateralValue,
+        greatestLoanAsset: loanAsset,
+        greatestLoanValue: loanValue,
         totalDebt,
         totalLimit,
         liquidable: false,
     };
 }
-exports.calculateLiquidationData = calculateLiquidationData;
 function predictHealthFactor(args) {
-    const liquidationData = calculateLiquidationData(args.assetsConfig, args.assetsData, args.balances, args.prices, args.masterConstants);
+    const liquidationData = calculateLiquidationData(args.assetsConfig, args.assetsData, args.principals, args.prices, args.poolConfig);
     const tokenHash = (0, sha256BigInt_1.sha256Hash)(args.tokenSymbol);
     const assetConfig = args.assetsConfig.get(tokenHash);
     const assetPrice = Number(args.prices.get(tokenHash));
@@ -223,16 +351,16 @@ function predictHealthFactor(args) {
     const changeType = args.balanceChangeType;
     if (currentAmount != null && currentAmount != 0n) {
         if (changeType == User_1.BalanceChangeType.Borrow) {
-            totalBorrow += currentBalance * (1 + Number(assetConfig.originationFee) / Number(args.masterConstants.ASSET_ORIGINATION_FEE_SCALE));
+            totalBorrow += currentBalance * (1 + Number(assetConfig.originationFee) / Number(args.poolConfig.masterConstants.ASSET_ORIGINATION_FEE_SCALE));
         }
         else if (changeType == User_1.BalanceChangeType.Repay) {
             totalBorrow -= currentBalance;
         }
         else if (changeType == User_1.BalanceChangeType.Withdraw) {
-            totalLimit -= currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.masterConstants.ASSET_COEFFICIENT_SCALE);
+            totalLimit -= currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE);
         }
         else if (changeType == User_1.BalanceChangeType.Supply) {
-            totalLimit += currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.masterConstants.ASSET_COEFFICIENT_SCALE);
+            totalLimit += currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE);
         }
     }
     if (Number(totalLimit) == 0) {
@@ -240,4 +368,3 @@ function predictHealthFactor(args) {
     }
     return Math.min(Math.max(1 - totalBorrow / totalLimit, 0), 1); // let's limit a result to zero below and one above
 }
-exports.predictHealthFactor = predictHealthFactor;

package/dist/api/parser.d.ts

@@ -1,8 +1,8 @@
 import { Dictionary, DictionaryValue } from '@ton/core';
-import { AssetConfig, AssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, MasterData, PoolAssetsConfig } from '../types/Master';
+import { AssetConfig, AssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, MasterData, PoolAssetsConfig, PoolConfig } from '../types/Master';
 import { UserData, UserLiteData } from '../types/User';
 export declare function createAssetData(): DictionaryValue<AssetData>;
 export declare function createAssetConfig(): DictionaryValue<AssetConfig>;
 export declare function parseMasterData(masterDataBOC: string, poolAssetsConfig: PoolAssetsConfig, masterConstants: MasterConstants): MasterData;
-export declare function parseUserLiteData(userDataBOC: string, assetsData: ExtendedAssetsData, assetsConfig: ExtendedAssetsConfig, poolAssetsConfig: PoolAssetsConfig, masterConstants: MasterConstants, testnet?: boolean, applyDust?: boolean): UserLiteData;
-export declare function parseUserData(userLiteData: UserLiteData, assetsData: ExtendedAssetsData, assetsConfig: ExtendedAssetsConfig, prices: Dictionary<bigint, bigint>, poolAssetConfig: PoolAssetsConfig, masterConstants: MasterConstants, applyDust?: boolean): UserData;
+export declare function parseUserLiteData(userDataBOC: string, assetsData: ExtendedAssetsData, assetsConfig: ExtendedAssetsConfig, poolConfig: PoolConfig, applyDust?: boolean): UserLiteData;
+export declare function parseUserData(userLiteData: UserLiteData, assetsData: ExtendedAssetsData, assetsConfig: ExtendedAssetsConfig, prices: Dictionary<bigint, bigint>, poolConfig: PoolConfig, applyDust?: boolean): UserData;

package/dist/api/parser.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseUserData = exports.parseUserLiteData = exports.parseMasterData = exports.createAssetConfig = exports.createAssetData = void 0;
+exports.createAssetData = createAssetData;
+exports.createAssetConfig = createAssetConfig;
+exports.parseMasterData = parseMasterData;
+exports.parseUserLiteData = parseUserLiteData;
+exports.parseUserData = parseUserData;
 const core_1 = require("@ton/core");
 const math_1 = require("./math");
 const helpers_1 = require("./helpers");
@@ -50,7 +54,6 @@ function createAssetData() {
         },
     };
 }
-exports.createAssetData = createAssetData;
 function createAssetConfig() {
     return {
         serialize: (src, builder) => {
@@ -124,7 +127,6 @@ function createAssetConfig() {
         },
     };
 }
-exports.createAssetConfig = createAssetConfig;
 function parseMasterData(masterDataBOC, poolAssetsConfig, masterConstants) {
     const masterSlice = core_1.Cell.fromBase64(masterDataBOC).beginParse();
     const meta = masterSlice.loadRef().beginParse().loadStringTail();
@@ -180,8 +182,9 @@ function parseMasterData(masterDataBOC, poolAssetsConfig, masterConstants) {
         apy: apy,
     };
 }
-exports.parseMasterData = parseMasterData;
-function parseUserLiteData(userDataBOC, assetsData, assetsConfig, poolAssetsConfig, masterConstants, testnet = false, applyDust = false) {
+function parseUserLiteData(userDataBOC, assetsData, assetsConfig, poolConfig, applyDust = true) {
+    const poolAssetsConfig = poolConfig.poolAssetsConfig;
+    const masterConstants = poolConfig.masterConstants;
     const userSlice = core_1.Cell.fromBase64(userDataBOC).beginParse();
     const codeVersion = userSlice.loadCoins();
     const masterAddress = userSlice.loadAddress();
@@ -213,16 +216,22 @@ function parseUserLiteData(userDataBOC, assetsData, assetsConfig, poolAssetsConf
     }
     */
     userSlice.endParse();
+    const isV5Main = (0, math_1.isV5MainPoolContract)(poolConfig);
     const userBalances = core_1.Dictionary.empty();
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetData = assetsData.get(asset.assetId);
         const assetConfig = assetsConfig.get(asset.assetId);
-        let principals = principalsDict.get(asset.assetId) || 0n;
-        if (applyDust && (principals > -assetConfig.dust && principals < assetConfig.dust)) { // abs(principals) < dust
-            principals = 0n;
+        let principal = principalsDict.get(asset.assetId) || 0n;
+        let balance = (0, math_1.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: User_1.BalanceType.supply,
+            };
             principalsDict.set(asset.assetId, 0n);
         }
-        const balance = (0, math_1.presentValue)(assetData.sRate, assetData.bRate, principals, masterConstants);
         userBalances.set(asset.assetId, balance);
     }
     return {
@@ -243,24 +252,27 @@ function parseUserLiteData(userDataBOC, assetsData, assetsConfig, poolAssetsConf
         backupCell2: backupCell2, */
     };
 }
-exports.parseUserLiteData = parseUserLiteData;
-function parseUserData(userLiteData, assetsData, assetsConfig, prices, poolAssetConfig, masterConstants, applyDust = false) {
+function parseUserData(userLiteData, assetsData, assetsConfig, prices, poolConfig, applyDust = true) {
+    const poolAssetsConfig = poolConfig.poolAssetsConfig;
+    const masterConstants = poolConfig.masterConstants;
     const withdrawalLimits = core_1.Dictionary.empty();
     const borrowLimits = core_1.Dictionary.empty();
     let supplyBalance = 0n;
     let borrowBalance = 0n;
-    for (const [_, asset] of Object.entries(poolAssetConfig)) {
+    const isV5Main = (0, math_1.isV5MainPoolContract)(poolConfig);
+    for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetData = assetsData.get(asset.assetId);
         const assetConfig = assetsConfig.get(asset.assetId);
-        let principals = userLiteData.principals.get(asset.assetId) || 0n;
-        if (applyDust && (principals > -assetConfig.dust && principals < assetConfig.dust)) { // abs(principals) < dust
-            principals = 0n;
+        let principal = userLiteData.principals.get(asset.assetId) || 0n;
+        const balance = (0, math_1.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);
         }
-        const balance = (0, math_1.presentValue)(assetData.sRate, assetData.bRate, principals, masterConstants);
         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);
         const balance = userLiteData.balances.get(asset.assetId);
         if (balance.type === User_1.BalanceType.supply) {
@@ -271,16 +283,17 @@ function parseUserData(userLiteData, assetsData, assetsConfig, prices, poolAsset
         }
     }
     const availableToBorrow = (0, math_1.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);
         const assetData = assetsData.get(asset.assetId);
         const balance = userLiteData.balances.get(asset.assetId);
         if (balance.type === User_1.BalanceType.supply) {
-            withdrawalLimits.set(asset.assetId, (0, math_1.bigIntMax)((0, math_1.bigIntMin)(assetData.balance, ((supplyBalance -
-                (borrowBalance * masterConstants.ASSET_COEFFICIENT_SCALE) / assetConfig.collateralFactor) *
-                10n ** assetConfig.decimals) /
-                prices.get(asset.assetId) -
-                5n, balance.amount), 0n));
+            if ((0, math_1.isV5MainPoolContract)(poolConfig)) {
+                withdrawalLimits.set(asset.assetId, (0, math_1.calculateMaximumWithdrawAmountOld)(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants, asset.assetId));
+            }
+            else {
+                withdrawalLimits.set(asset.assetId, (0, math_1.calculateMaximumWithdrawAmount)(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants, asset.assetId));
+            }
         }
         borrowLimits.set(asset.assetId, (0, math_1.bigIntMin)((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(asset.assetId), assetData.balance));
     }
@@ -288,7 +301,7 @@ function parseUserData(userLiteData, assetsData, assetsConfig, prices, poolAsset
     const limitUsedPercent = limitUsed === 0n
         ? 0
         : Number(BigInt(1e9) - (availableToBorrow * BigInt(1e9)) / (borrowBalance + availableToBorrow)) / 1e7;
-    const liquidationData = (0, math_1.calculateLiquidationData)(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants);
+    const liquidationData = (0, math_1.calculateLiquidationData)(assetsConfig, assetsData, userLiteData.principals, prices, poolConfig);
     const healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
     return {
         ...userLiteData,
@@ -303,4 +316,3 @@ function parseUserData(userLiteData, assetsData, assetsConfig, prices, poolAsset
         healthFactor: healthFactor,
     };
 }
-exports.parseUserData = parseUserData;

package/dist/api/prices.d.ts

@@ -1,2 +1,2 @@
 import { PriceData } from '../types/Common';
-export declare function getPricesByNft(nftId: string, endpoints?: string[]): Promise<PriceData>;
+export declare function getPrices(endpoints?: string[], nftId?: string): Promise<PriceData>;

package/dist/api/prices.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPricesByNft = void 0;
+exports.getPrices = getPrices;
 const core_1 = require("@ton/core");
-async function getPricesByNft(nftId, endpoints = ["api.stardust-mainnet.iotaledger.net"]) {
+const general_1 = require("../constants/general");
+async function getPrices(endpoints = ["api.stardust-mainnet.iotaledger.net"], nftId = general_1.MAIN_POOL_NFT_ID) {
     return await Promise.any(endpoints.map(x => loadPrices(nftId, x)));
 }
-exports.getPricesByNft = getPricesByNft;
 async function loadPrices(nftId, endpoint = "api.stardust-mainnet.iotaledger.net") {
     let result = await fetch(`https://${endpoint}/api/indexer/v1/outputs/nft/${nftId}`, {
         headers: { accept: 'application/json' },

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export declare const MINIMAL_ORACLES_NUMBER = 5;
+export declare const TTL_ORACLE_DATA_SEC = 170;

package/dist/config.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTL_ORACLE_DATA_SEC = exports.MINIMAL_ORACLES_NUMBER = void 0;
+exports.MINIMAL_ORACLES_NUMBER = 5;
+exports.TTL_ORACLE_DATA_SEC = 170; // todo back to 120

package/dist/constants/assets.d.ts

@@ -1,8 +1,7 @@
 import { PoolAssetConfig } from "../types/Master";
+export declare const UNDEFINED_ASSET: PoolAssetConfig;
 export declare const TON_MAINNET: PoolAssetConfig;
-export declare const TON_TESTNET: import("../types/Master").PoolTonAssetConfig & {
-    name: string;
-};
+export declare const TON_TESTNET: PoolAssetConfig;
 export declare const JUSDT_MAINNET: PoolAssetConfig;
 export declare const JUSDC_MAINNET: PoolAssetConfig;
 export declare const STTON_MAINNET: PoolAssetConfig;

package/dist/constants/assets.js

@@ -1,12 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.USDT_STORM_MAINNET = exports.TON_STORM_MAINNET = exports.TONUSDT_DEDUST_MAINNET = exports.STTON_TESTNET = exports.JUSDC_TESTNET = exports.JUSDT_TESTNET = exports.USDT_MAINNET = exports.TSTON_MAINNET = exports.STTON_MAINNET = exports.JUSDC_MAINNET = exports.JUSDT_MAINNET = exports.TON_TESTNET = exports.TON_MAINNET = void 0;
+exports.USDT_STORM_MAINNET = exports.TON_STORM_MAINNET = exports.TONUSDT_DEDUST_MAINNET = exports.STTON_TESTNET = exports.JUSDC_TESTNET = exports.JUSDT_TESTNET = exports.USDT_MAINNET = exports.TSTON_MAINNET = exports.STTON_MAINNET = exports.JUSDC_MAINNET = exports.JUSDT_MAINNET = exports.TON_TESTNET = exports.TON_MAINNET = exports.UNDEFINED_ASSET = void 0;
 const core_1 = require("@ton/core");
 const sha256BigInt_1 = require("../utils/sha256BigInt");
 const general_1 = require("./general");
+exports.UNDEFINED_ASSET = {
+    name: 'undefined_asset',
+    assetId: -1n,
+    jettonMasterAddress: general_1.NULL_ADDRESS, // fake
+    jettonWalletCode: core_1.Cell.EMPTY
+};
 exports.TON_MAINNET = {
     name: 'TON',
-    assetId: (0, sha256BigInt_1.sha256Hash)('TON')
+    assetId: (0, sha256BigInt_1.sha256Hash)('TON'),
+    jettonMasterAddress: general_1.NULL_ADDRESS, // fake
+    jettonWalletCode: core_1.Cell.EMPTY
 };
 exports.TON_TESTNET = exports.TON_MAINNET;
 exports.JUSDT_MAINNET = {