@evaafi/sdk 0.5.3 → 0.5.4

package/dist/types/User.d.ts

@@ -1,5 +1,5 @@
 import { Address, Cell, Dictionary } from '@ton/core';
-import { AssetConfig, ExtendedAssetData } from './Master';
+import { ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants } from './Master';
 export declare enum BalanceType {
     supply = "supply",
     borrow = "borrow"
@@ -70,6 +70,7 @@ export type PredictHealthFactorArgs = {
     tokenSymbol: string;
     balances: Dictionary<bigint, bigint>;
     prices: Dictionary<bigint, bigint>;
-    assetsData: Dictionary<bigint, ExtendedAssetData>;
-    assetsConfig: Dictionary<bigint, AssetConfig>;
+    assetsData: ExtendedAssetsData;
+    assetsConfig: ExtendedAssetsConfig;
+    masterConstants: MasterConstants;
 };

package/dist/utils/userJettonWallet.d.ts

@@ -1,2 +1,3 @@
 import { Address } from '@ton/core';
-export declare function getUserJettonWallet(ownerAddress: Address, assetID: bigint, network: 'mainnet' | 'testnet'): Address;
+import { PoolAssetConfig, PoolJettonAssetConfig } from '../types/Master';
+export declare function getUserJettonWallet(ownerAddress: Address, poolAssetConfig: PoolAssetConfig & PoolJettonAssetConfig): Address;

package/dist/utils/userJettonWallet.js

@@ -2,71 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUserJettonWallet = void 0;
 const core_1 = require("@ton/core");
-const constants_1 = require("../constants");
-function getUserJettonWallet(ownerAddress, assetID, network) {
-    const builder = (0, core_1.beginCell)().storeCoins(0).storeAddress(ownerAddress);
-    let jettonWalletCode;
-    switch (assetID) {
-        case constants_1.MAINNET_ASSETS_ID.jUSDT:
-            if (network === 'mainnet') {
-                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.jUSDT_MAINNET);
-                jettonWalletCode = constants_1.JETTON_WALLETS_CODE.jUSDT_MAINNET;
-            }
-            else {
-                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.jUSDT_TESTNET);
-                jettonWalletCode = constants_1.JETTON_WALLETS_CODE.jUSDT_TESTNET;
-            }
-            break;
-        case constants_1.MAINNET_ASSETS_ID.jUSDC:
-            if (network === 'mainnet') {
-                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.jUSDC_MAINNET);
-                jettonWalletCode = constants_1.JETTON_WALLETS_CODE.jUSDC_MAINNET;
-            }
-            else {
-                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.jUSDC_TESTNET);
-                jettonWalletCode = constants_1.JETTON_WALLETS_CODE.jUSDC_TESTNET;
-            }
-            break;
-        case constants_1.MAINNET_ASSETS_ID.stTON:
-            if (network === 'mainnet') {
-                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.stTON_MAINNET);
-                jettonWalletCode = constants_1.JETTON_WALLETS_CODE.stTON_MAINNET;
-            }
-            else {
-                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.stTON_TESTNET);
-                jettonWalletCode = constants_1.JETTON_WALLETS_CODE.stTON_TESTNET;
-            }
-            break;
-        case constants_1.MAINNET_ASSETS_ID.tsTON:
-            if (network === 'mainnet') {
-                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.tsTON_MAINNET);
-                jettonWalletCode = constants_1.JETTON_WALLETS_CODE.tsTON_MAINNET;
-            }
-            else {
-                // builder.storeAddress(JETTON_MASTER_ADDRESSES.tsTON_TESTNET);
-                // jettonWalletCode = JETTON_WALLETS_CODE.tsTON_TESTNET;
-                throw new Error('tsTON is not supported on testnet');
-            }
-            break;
-        case constants_1.MAINNET_ASSETS_ID.USDT:
-            if (network === 'mainnet') {
-                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.USDT_MAINNET);
-                jettonWalletCode = constants_1.JETTON_WALLETS_CODE.USDT_MAINNET;
-            }
-            else {
-                // builder.storeAddress(JETTON_MASTER_ADDRESSES.USDT_TESTNET);
-                // jettonWalletCode = JETTON_WALLETS_CODE.USDT_TESTNET;
-                throw new Error('USDT is not supported on testnet');
-            }
-            break;
-        default:
-            throw new Error('Unsupported asset');
+function getUserJettonWallet(ownerAddress, poolAssetConfig) {
+    const jettonMasterAddress = poolAssetConfig.jettonMasterAddress;
+    const jettonWalletCode = poolAssetConfig.jettonWalletCode;
+    if (poolAssetConfig.name === 'USDT') {
+        const lib_prep = (0, core_1.beginCell)().storeUint(2, 8).storeBuffer(jettonWalletCode.hash()).endCell();
+        const jwallet_code = new core_1.Cell({ exotic: true, bits: lib_prep.bits, refs: lib_prep.refs });
+        const jettonData = (0, core_1.beginCell)()
+            .storeUint(0, 4)
+            .storeCoins(0)
+            .storeAddress(ownerAddress)
+            .storeAddress(jettonMasterAddress)
+            .endCell();
+        const stateInit = (0, core_1.beginCell)()
+            .store((0, core_1.storeStateInit)({
+            code: jwallet_code,
+            data: jettonData
+        }))
+            .endCell();
+        return new core_1.Address(0, stateInit.hash());
     }
-    const data = builder.storeRef(jettonWalletCode).endCell();
+    if (poolAssetConfig.name === 'tsTON') {
+        const lib_prep = (0, core_1.beginCell)().storeUint(2, 8).storeBuffer(jettonWalletCode.hash()).endCell();
+        const jwallet_code = new core_1.Cell({ exotic: true, bits: lib_prep.bits, refs: lib_prep.refs });
+        const jettonData = (0, core_1.beginCell)()
+            .storeCoins(0)
+            .storeAddress(ownerAddress)
+            .storeAddress(jettonMasterAddress)
+            .storeRef(jwallet_code)
+            .storeCoins(0)
+            .storeUint(0, 48)
+            .endCell();
+        const stateInit = (0, core_1.beginCell)()
+            .store((0, core_1.storeStateInit)({
+            code: jwallet_code,
+            data: jettonData
+        }))
+            .endCell();
+        return new core_1.Address(0, stateInit.hash());
+    }
+    const jettonData = (0, core_1.beginCell)()
+        .storeCoins(0)
+        .storeAddress(ownerAddress)
+        .storeAddress(jettonMasterAddress)
+        .storeRef(jettonWalletCode)
+        .endCell();
     const stateInit = (0, core_1.beginCell)()
         .store((0, core_1.storeStateInit)({
         code: jettonWalletCode,
-        data: data,
+        data: jettonData
     }))
         .endCell();
     return new core_1.Address(0, stateInit.hash());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evaafi/sdk",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "SDK for EVAA contracts",
   "main": "dist/index.js",
   "files": [
@@ -18,11 +18,14 @@
   "license": "MIT",
   "homepage": "https://github.com/evaafi/sdk#readme",
   "devDependencies": {
+    "@orbs-network/ton-access": "^2.3.3",
     "@ton/core": "0.56.0",
     "@tonconnect/sdk": "^3.0.0",
+    "@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",
     "typescript": "^5.3.3"
   },
@@ -30,5 +33,9 @@
     "@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,4 @@
-import { AssetConfig, AssetData, AssetInterest, ExtendedAssetData } from '../types/Master';
-import { MASTER_CONSTANTS } from '../constants';
+import { AssetConfig, AssetData, AssetInterest, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants } from '../types/Master';
 import { Dictionary } from '@ton/core';
 import { BalanceChangeType, BalanceType, LiquidationData, PredictHealthFactorArgs, UserBalance } from '../types/User';
 import { sha256Hash } from '../utils/sha256BigInt';
@@ -19,20 +18,20 @@ export function bigIntMin(...args: bigint[]): bigint {
     return args.reduce((m, e) => (e < m ? e : m));
 }
 
-export function calculatePresentValue(index: bigint, principalValue: bigint): bigint {
-    return (principalValue * index) / MASTER_CONSTANTS.FACTOR_SCALE;
+export function calculatePresentValue(index: bigint, principalValue: bigint, masterConstants: MasterConstants): bigint {
+    return (principalValue * index) / masterConstants.FACTOR_SCALE;
 }
 
-export function calculateCurrentRates(assetConfig: AssetConfig, assetData: AssetData) {
+export function calculateCurrentRates(assetConfig: AssetConfig, assetData: AssetData, masterConstants: MasterConstants) {
     const now = BigInt(Math.floor(Date.now() / 1000));
     const timeElapsed = now - assetData.lastAccural;
-    const { supplyInterest, borrowInterest } = calculateAssetInterest(assetConfig, assetData);
+    const { supplyInterest, borrowInterest } = calculateAssetInterest(assetConfig, assetData, masterConstants);
 
     if (timeElapsed > 0) {
         const updatedSRate =
-            assetData.sRate + mulFactor(MASTER_CONSTANTS.FACTOR_SCALE, assetData.sRate, supplyInterest * timeElapsed);
+            assetData.sRate + mulFactor(masterConstants.FACTOR_SCALE, assetData.sRate, supplyInterest * timeElapsed);
         const updatedBRate =
-            assetData.bRate + mulFactor(MASTER_CONSTANTS.FACTOR_SCALE, assetData.bRate, borrowInterest * timeElapsed);
+            assetData.bRate + mulFactor(masterConstants.FACTOR_SCALE, assetData.bRate, borrowInterest * timeElapsed);
         return {
             sRate: updatedSRate,
             bRate: updatedBRate,
@@ -52,9 +51,10 @@ export function calculateCurrentRates(assetConfig: AssetConfig, assetData: Asset
 }
 
 export function calculateAssetData(
-    assetsConfigDict: Dictionary<bigint, AssetConfig>,
+    assetsConfigDict: ExtendedAssetsConfig,
     assetsDataDict: Dictionary<bigint, AssetData>,
     assetId: bigint,
+    masterConstants: MasterConstants
 ): ExtendedAssetData {
     const config = assetsConfigDict.get(assetId);
     const data = assetsDataDict.get(assetId);
@@ -63,7 +63,7 @@ export function calculateAssetData(
         throw new Error('Asset Data or Config is not accessible');
     }
 
-    const { sRate, bRate, supplyInterest, borrowInterest, now } = calculateCurrentRates(config, data);
+    const { sRate, bRate, supplyInterest, borrowInterest, now } = calculateCurrentRates(config, data, masterConstants);
     data.sRate = sRate || 0n;
     data.bRate = bRate || 0n;
     data.lastAccural = now;
@@ -78,36 +78,36 @@ export function calculateAssetData(
     };
 }
 
-export function calculateAssetInterest(assetConfig: AssetConfig, assetData: AssetData): AssetInterest {
-    const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply);
-    const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow);
+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);
     let utilization = 0n;
     let supplyInterest = 0n;
     let borrowInterest = 0n;
 
     if (totalSupply !== 0n) {
-        utilization = (totalBorrow * MASTER_CONSTANTS.FACTOR_SCALE) / totalSupply;
+        utilization = (totalBorrow * masterConstants.FACTOR_SCALE) / totalSupply;
     }
 
     if (utilization <= assetConfig.targetUtilization) {
         borrowInterest =
             assetConfig.baseBorrowRate +
-            mulFactor(MASTER_CONSTANTS.FACTOR_SCALE, assetConfig.borrowRateSlopeLow, utilization);
+            mulFactor(masterConstants.FACTOR_SCALE, assetConfig.borrowRateSlopeLow, utilization);
     } else {
         borrowInterest =
             assetConfig.baseBorrowRate +
-            mulFactor(MASTER_CONSTANTS.FACTOR_SCALE, assetConfig.borrowRateSlopeLow, assetConfig.targetUtilization) +
+            mulFactor(masterConstants.FACTOR_SCALE, assetConfig.borrowRateSlopeLow, assetConfig.targetUtilization) +
             mulFactor(
-                MASTER_CONSTANTS.FACTOR_SCALE,
+                masterConstants.FACTOR_SCALE,
                 assetConfig.borrowRateSlopeHigh,
                 utilization - assetConfig.targetUtilization,
             );
     }
 
     supplyInterest = mulDiv(
-        mulDiv(borrowInterest, utilization, MASTER_CONSTANTS.FACTOR_SCALE),
-        MASTER_CONSTANTS.ASSET_RESERVE_FACTOR_SCALE - assetConfig.reserveFactor,
-        MASTER_CONSTANTS.ASSET_RESERVE_FACTOR_SCALE,
+        mulDiv(borrowInterest, utilization, masterConstants.FACTOR_SCALE),
+        masterConstants.ASSET_RESERVE_FACTOR_SCALE - assetConfig.reserveFactor,
+        masterConstants.ASSET_RESERVE_FACTOR_SCALE,
     );
 
     return {
@@ -117,10 +117,11 @@ export function calculateAssetInterest(assetConfig: AssetConfig, assetData: Asse
 }
 
 export function getAvailableToBorrow(
-    assetsConfig: Dictionary<bigint, AssetConfig>,
-    assetsData: Dictionary<bigint, ExtendedAssetData>,
+    assetsConfig: ExtendedAssetsConfig,
+    assetsData: ExtendedAssetsData,
     principals: Dictionary<bigint, bigint>,
     prices: Dictionary<bigint, bigint>,
+    masterConstants: MasterConstants
 ): bigint {
     let borrowLimit = 0n;
     let borrowAmount = 0n;
@@ -132,27 +133,27 @@ export function getAvailableToBorrow(
         const principal = principals.get(assetID) as bigint;
 
         if (principal < 0) {
-            borrowAmount += (calculatePresentValue(assetData.bRate, -principal) * price) / 10n ** assetConfig.decimals;
+            borrowAmount += (calculatePresentValue(assetData.bRate, -principal, masterConstants) * price) / 10n ** assetConfig.decimals;
         } else if (principal > 0) {
             borrowLimit +=
-                (calculatePresentValue(assetData.sRate, principal) * price * assetConfig.collateralFactor) /
+                (calculatePresentValue(assetData.sRate, principal, masterConstants) * price * assetConfig.collateralFactor) /
                 10n ** assetConfig.decimals /
-                MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE;
+                masterConstants.ASSET_COEFFICIENT_SCALE;
         }
     }
 
     return borrowLimit - borrowAmount;
 }
 
-export function presentValue(sRate: bigint, bRate: bigint, principalValue: bigint): UserBalance {
+export function presentValue(sRate: bigint, bRate: bigint, principalValue: bigint, masterConstants: MasterConstants): UserBalance {
     if (principalValue > 0) {
         return {
-            amount: calculatePresentValue(sRate, principalValue),
+            amount: calculatePresentValue(sRate, principalValue, masterConstants),
             type: BalanceType.supply,
         };
     } else if (principalValue < 0) {
         return {
-            amount: calculatePresentValue(bRate, -principalValue),
+            amount: calculatePresentValue(bRate, -principalValue, masterConstants),
             type: BalanceType.borrow,
         };
     } else {
@@ -164,10 +165,11 @@ export function presentValue(sRate: bigint, bRate: bigint, principalValue: bigin
 }
 
 export function calculateLiquidationData(
-    assetsConfig: Dictionary<bigint, AssetConfig>,
-    assetsData: Dictionary<bigint, ExtendedAssetData>,
+    assetsConfig: ExtendedAssetsConfig,
+    assetsData: ExtendedAssetsData,
     principals: Dictionary<bigint, bigint>,
     prices: Dictionary<bigint, bigint>,
+    masterConstants: MasterConstants,
 ): LiquidationData {
     let gCollateralValue = 0n;
     let gCollateralAsset = 0n;
@@ -184,7 +186,7 @@ export function calculateLiquidationData(
             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) / MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE;
+            totalLimit += (assetWorth * assetConfig.liquidationThreshold) / masterConstants.ASSET_COEFFICIENT_SCALE;
             if (assetWorth > gCollateralValue) {
                 gCollateralValue = assetWorth;
                 gCollateralAsset = key;
@@ -209,7 +211,7 @@ export function calculateLiquidationData(
         values.push(
             (bigIntMax(gCollateralValue / 2n, bigIntMin(gCollateralValue, 10_000_000_000n)) *
                 loanDecimal *
-                MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE) /
+                masterConstants.ASSET_COEFFICIENT_SCALE) /
                 liquidationBonus /
                 gLoanAssetPrice,
         );
@@ -251,7 +253,7 @@ export function calculateLiquidationData(
 }
 
 export function predictHealthFactor(args: PredictHealthFactorArgs): number {
-    const liquidationData = calculateLiquidationData(args.assetsConfig, args.assetsData, args.balances, args.prices);
+    const liquidationData = calculateLiquidationData(args.assetsConfig, args.assetsData, args.balances, args.prices, args.masterConstants);
     const tokenHash = sha256Hash(args.tokenSymbol);
     
     const assetConfig = args.assetsConfig.get(tokenHash)!;
@@ -267,16 +269,15 @@ export function predictHealthFactor(args: PredictHealthFactorArgs): number {
     const currentBalance = assetPrice * Number(currentAmount) / Math.pow(10, decimals);
     const changeType = args.balanceChangeType;
 
-    if (currentAmount != null && !Number.isNaN(currentAmount) &&
-             Number.isFinite(currentAmount) && currentAmount != 0n) { 
+    if (currentAmount != null && currentAmount != 0n) { 
         if (changeType == BalanceChangeType.Borrow) {
-            totalBorrow += currentBalance * (1 + Number(assetConfig.originationFee) / Number(MASTER_CONSTANTS.ASSET_ORIGINATION_FEE_SCALE));
+            totalBorrow += currentBalance * (1 + Number(assetConfig.originationFee) / Number(args.masterConstants.ASSET_ORIGINATION_FEE_SCALE));
         } else if (changeType == BalanceChangeType.Repay) {
             totalBorrow -= currentBalance;
         } else if (changeType == BalanceChangeType.Withdraw) {
-            totalLimit -= currentBalance * Number(assetConfig.liquidationThreshold) / Number(MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE);
+            totalLimit -= currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.masterConstants.ASSET_COEFFICIENT_SCALE);
         } else if (changeType == BalanceChangeType.Supply) {
-            totalLimit += currentBalance * Number(assetConfig.liquidationThreshold) / Number(MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE);
+            totalLimit += currentBalance * Number(assetConfig.liquidationThreshold) / Number(args.masterConstants.ASSET_COEFFICIENT_SCALE);
         }
     }
     if (Number(totalLimit) == 0) {

package/src/api/parser.ts

@@ -1,6 +1,5 @@
 import { beginCell, Cell, Dictionary, DictionaryValue, Slice } from '@ton/core';
-import { AssetConfig, AssetData, ExtendedAssetData, MasterData } from '../types/Master';
-import { MAINNET_ASSETS_ID, MASTER_CONSTANTS, TESTNET_ASSETS_ID } from '../constants';
+import { AssetConfig, AssetData, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants, MasterData, PoolAssetsConfig } from '../types/Master';
 import {
     bigIntMax,
     bigIntMin,
@@ -134,8 +133,7 @@ export function createAssetConfig(): DictionaryValue<AssetConfig> {
     };
 }
 
-export function parseMasterData(masterDataBOC: string, testnet: boolean = false): MasterData {
-    const ASSETS_ID = testnet ? TESTNET_ASSETS_ID : MAINNET_ASSETS_ID;
+export function parseMasterData(masterDataBOC: string, poolAssetsConfig: PoolAssetsConfig, masterConstants: MasterConstants): MasterData {
     const masterSlice = Cell.fromBase64(masterDataBOC).beginParse();
     const meta = masterSlice.loadRef().beginParse().loadStringTail();
     const upgradeConfigParser = masterSlice.loadRef().beginParse();
@@ -163,10 +161,10 @@ export function parseMasterData(masterDataBOC: string, testnet: boolean = false)
         supply: Dictionary.empty<bigint, number>(),
         borrow: Dictionary.empty<bigint, number>(),
     };
-
-    for (const [tokenSymbol, assetID] of Object.entries(ASSETS_ID)) {
-        const assetData = calculateAssetData(assetsConfigDict, assetsDataDict, assetID);
-        assetsExtendedData.set(assetID, assetData);
+    
+    for (const [tokenSymbol, asset] of Object.entries(poolAssetsConfig)) {
+        const assetData = calculateAssetData(assetsConfigDict, assetsDataDict, asset.assetId, masterConstants);
+        assetsExtendedData.set(asset.assetId, assetData);
     }
 
     const masterConfig = {
@@ -179,14 +177,14 @@ export function parseMasterData(masterDataBOC: string, testnet: boolean = false)
 
     masterConfigSlice.endParse();
 
-    for (const [_, assetID] of Object.entries(ASSETS_ID)) {
-        const assetData = assetsExtendedData.get(assetID) as ExtendedAssetData;
-        const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply);
-        const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow);
-        assetsReserves.set(assetID, assetData.balance - totalSupply + totalBorrow);
+    for (const [_, asset] of Object.entries(poolAssetsConfig)) {
+        const assetData = assetsExtendedData.get(asset.assetId) as ExtendedAssetData;
+        const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply, masterConstants);
+        const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow, masterConstants);
+        assetsReserves.set(asset.assetId, assetData.balance - totalSupply + totalBorrow);
 
-        apy.supply.set(assetID, (1 + (Number(assetData.supplyInterest) / 1e12) * 24 * 3600) ** 365 - 1);
-        apy.borrow.set(assetID, (1 + (Number(assetData.borrowInterest) / 1e12) * 24 * 3600) ** 365 - 1);
+        apy.supply.set(asset.assetId, (1 + (Number(assetData.supplyInterest) / 1e12) * 24 * 3600) ** 365 - 1);
+        apy.borrow.set(asset.assetId, (1 + (Number(assetData.borrowInterest) / 1e12) * 24 * 3600) ** 365 - 1);
     }
 
     return {
@@ -202,12 +200,13 @@ export function parseMasterData(masterDataBOC: string, testnet: boolean = false)
 
 export function parseUserLiteData(
     userDataBOC: string,
-    assetsData: Dictionary<bigint, ExtendedAssetData>,
-    assetsConfig: Dictionary<bigint, AssetConfig>,
+    assetsData: ExtendedAssetsData,
+    assetsConfig: ExtendedAssetsConfig,
+    poolAssetsConfig: PoolAssetsConfig,
+    masterConstants: MasterConstants,
     testnet: boolean = false,
     applyDust: boolean = false
 ): UserLiteData {
-    const ASSETS_ID = testnet ? TESTNET_ASSETS_ID : MAINNET_ASSETS_ID;
     const userSlice = Cell.fromBase64(userDataBOC).beginParse();
 
     const codeVersion = userSlice.loadCoins();
@@ -243,17 +242,17 @@ export function parseUserLiteData(
 
     const userBalances = Dictionary.empty<bigint, UserBalance>();
 
-    for (const [_, assetID] of Object.entries(ASSETS_ID)) {
-        const assetData = assetsData.get(assetID) as ExtendedAssetData;
-        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
-        let principals = principalsDict.get(assetID) || 0n;
+    for (const [_, asset] of Object.entries(poolAssetsConfig)) {
+        const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
+        const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
+        let principals = principalsDict.get(asset.assetId) || 0n;
 
         if (applyDust && (principals > -assetConfig.dust && principals < assetConfig.dust)) {  // abs(principals) < dust
             principals = 0n;
-            principalsDict.set(assetID, 0n);
+            principalsDict.set(asset.assetId, 0n);
         }
-        const balance = presentValue(assetData.sRate, assetData.bRate, principals);
-        userBalances.set(assetID, balance);
+        const balance = presentValue(assetData.sRate, assetData.bRate, principals, masterConstants);
+        userBalances.set(asset.assetId, balance);
     }
 
     return {
@@ -277,60 +276,60 @@ export function parseUserLiteData(
 
 export function parseUserData(
     userLiteData: UserLiteData,
-    assetsData: Dictionary<bigint, ExtendedAssetData>,
-    assetsConfig: Dictionary<bigint, AssetConfig>,
+    assetsData: ExtendedAssetsData,
+    assetsConfig: ExtendedAssetsConfig,
     prices: Dictionary<bigint, bigint>,
-    testnet: boolean = false,
+    poolAssetConfig: PoolAssetsConfig,
+    masterConstants: MasterConstants,
     applyDust: boolean = false
 ): UserData {
-    const ASSETS_ID = testnet ? TESTNET_ASSETS_ID : MAINNET_ASSETS_ID;
     const withdrawalLimits = Dictionary.empty<bigint, bigint>();
     const borrowLimits = Dictionary.empty<bigint, bigint>();
 
     let supplyBalance = 0n;
     let borrowBalance = 0n;
-    for (const [_, assetID] of Object.entries(ASSETS_ID)) {
-        const assetData = assetsData.get(assetID) as ExtendedAssetData;
-        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
-        let principals = userLiteData.principals.get(assetID) || 0n;
+    for (const [_, asset] of Object.entries(poolAssetConfig)) {
+        const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
+        const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
+        let principals = userLiteData.principals.get(asset.assetId) || 0n;
 
         if (applyDust && (principals > -assetConfig.dust && principals < assetConfig.dust )) {  // abs(principals) < dust
             principals = 0n;
-            userLiteData.principals.set(assetID, 0n);
+            userLiteData.principals.set(asset.assetId, 0n);
         }
 
-        const balance = presentValue(assetData.sRate, assetData.bRate, principals);
-        userLiteData.balances.set(assetID, balance);
+        const balance = presentValue(assetData.sRate, assetData.bRate, principals, masterConstants);
+        userLiteData.balances.set(asset.assetId, balance);
     }
 
-    for (const [_, assetID] of Object.entries(ASSETS_ID)) {
-        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
-        const balance = userLiteData.balances.get(assetID) as UserBalance;
+    for (const [_, asset] of Object.entries(poolAssetConfig)) {
+        const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
+        const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
 
         if (balance.type === BalanceType.supply) {
-            supplyBalance += (balance.amount * prices.get(assetID)!) / 10n ** assetConfig.decimals;
+            supplyBalance += (balance.amount * prices.get(asset.assetId)!) / 10n ** assetConfig.decimals;
         }
         if (balance.type === BalanceType.borrow) {
-            borrowBalance += (balance.amount * prices.get(assetID)!) / 10n ** assetConfig.decimals;
+            borrowBalance += (balance.amount * prices.get(asset.assetId)!) / 10n ** assetConfig.decimals;
         }
     }
 
-    const availableToBorrow = getAvailableToBorrow(assetsConfig, assetsData, userLiteData.principals, prices);
-    for (const [_, assetID] of Object.entries(ASSETS_ID)) {
-        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
-        const assetData = assetsData.get(assetID) as ExtendedAssetData;
-        const balance = userLiteData.balances.get(assetID) as UserBalance;
+    const availableToBorrow = getAvailableToBorrow(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants);
+    for (const [_, asset] of Object.entries(poolAssetConfig)) {
+        const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
+        const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
+        const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
 
         if (balance.type === BalanceType.supply) {
             withdrawalLimits.set(
-                assetID,
+                asset.assetId,
                 bigIntMax(
                     bigIntMin(
                         assetData.balance,
                         ((supplyBalance -
-                            (borrowBalance * MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE) / assetConfig.collateralFactor) *
+                            (borrowBalance * masterConstants.ASSET_COEFFICIENT_SCALE) / assetConfig.collateralFactor) *
                             10n ** assetConfig.decimals) /
-                            prices.get(assetID)! -
+                            prices.get(asset.assetId)! -
                             5n,
                         balance.amount,
                     ),
@@ -339,8 +338,8 @@ export function parseUserData(
             );
         }
         borrowLimits.set(
-            assetID,
-            bigIntMin((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(assetID)!, assetData.balance),
+            asset.assetId,
+            bigIntMin((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(asset.assetId)!, assetData.balance),
         );
     }
 
@@ -350,7 +349,7 @@ export function parseUserData(
             ? 0
             : Number(BigInt(1e9) - (availableToBorrow * BigInt(1e9)) / (borrowBalance + availableToBorrow)) / 1e7;
 
-    const liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.principals, prices);
+    const liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants);
     const healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
 
     return {

package/src/api/prices.ts

@@ -1,5 +1,4 @@
 import { beginCell, Cell, Dictionary } from '@ton/core';
-import { NFT_ID } from '../constants';
 import { PriceData } from '../types/Common';
 
 type NftData = {
@@ -39,12 +38,12 @@ type OutputData = {
     };
 }
 
-export async function getPrices(endpoints: string[] = ["api.stardust-mainnet.iotaledger.net"]) {
-    return await Promise.any(endpoints.map(x => loadPrices(x)));
+export async function getPricesByNft(nftId: string, endpoints: string[] = ["api.stardust-mainnet.iotaledger.net"]) {
+    return await Promise.any(endpoints.map(x => loadPrices(nftId, x)));
 }
 
-async function loadPrices(endpoint: String = "api.stardust-mainnet.iotaledger.net"): Promise<PriceData> {
-    let result = await fetch(`https://${endpoint}/api/indexer/v1/outputs/nft/${NFT_ID}`, {
+async function loadPrices(nftId: string, endpoint: string = "api.stardust-mainnet.iotaledger.net"): Promise<PriceData> {
+    let result = await fetch(`https://${endpoint}/api/indexer/v1/outputs/nft/${nftId}`, {
         headers: { accept: 'application/json' },
     });
     let outputId = (await result.json()) as NftData;