@evaafi/sdk 0.5.4 → 0.5.6-a

package/dist/utils/priceUtils.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumDicts = exports.packOraclesData = exports.createOracleDataProof = exports.packPrices = exports.packAssetsData = exports.getMedianPrice = exports.verifyPrices = exports.parsePrices = exports.loadPrices = void 0;
+const core_1 = require("@ton/core");
+const config_1 = require("../config");
+const merkleProof_1 = require("./merkleProof");
+async function loadPrices(oracleNftId, endpoints) {
+    return await Promise.any(endpoints.map(x => loadOracleData(oracleNftId, x)));
+}
+exports.loadPrices = loadPrices;
+async function loadOracleData(oracleNftId, endpoint) {
+    let result = await fetch(`https://${endpoint}/api/indexer/v1/outputs/nft/${oracleNftId}`, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(5000)
+    });
+    let outputId = (await result.json());
+    result = await fetch(`https://${endpoint}/api/core/v2/outputs/${outputId.items[0]}`, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(5000)
+    });
+    return await result.json();
+}
+async function parsePrices(outputData, oracleId) {
+    const data = JSON.parse(decodeURIComponent(outputData.output.features[0].data.replace('0x', '').replace(/[0-9a-f]{2}/g, '%$&')));
+    try {
+        const pricesCell = core_1.Cell.fromBoc(Buffer.from(data['packedPrices'], 'hex'))[0];
+        const signature = Buffer.from(data['signature'], 'hex');
+        const publicKey = Buffer.from(data['publicKey'], 'hex');
+        const timestamp = Number(data['timestamp']);
+        return {
+            dict: pricesCell.beginParse().loadRef().beginParse().loadDictDirect(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.BigVarUint(4)),
+            dataCell: (0, core_1.beginCell)().storeRef(pricesCell).storeBuffer(signature).endCell(),
+            oracleId: oracleId,
+            signature: signature,
+            pubkey: publicKey,
+            timestamp: timestamp,
+        };
+    }
+    catch (error) {
+        console.log(oracleId, data, error);
+        throw Error();
+    }
+}
+exports.parsePrices = parsePrices;
+function verifyPrices(assets) {
+    return function (priceData) {
+        const timestamp = Date.now() / 1000;
+        const pricesTime = priceData.timestamp;
+        for (const asset of assets) {
+            if (!priceData.dict.has(asset.assetId)) {
+                return false;
+            }
+        }
+        // console.log('timestamp', timestamp, 'pricestime', pricesTime, timestamp - pricesTime);
+        return timestamp - pricesTime < config_1.TTL_ORACLE_DATA_SEC;
+    };
+}
+exports.verifyPrices = verifyPrices;
+function getMedianPrice(pricesData, asset) {
+    const sorted = pricesData.map(x => x.dict.get(asset)).sort((a, b) => Number(a) - Number(b));
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[mid - 1] + sorted[mid]) / 2n;
+    }
+    else {
+        return sorted[mid];
+    }
+}
+exports.getMedianPrice = getMedianPrice;
+function packAssetsData(assetsData) {
+    if (assetsData.length == 0) {
+        throw new Error("No assets data to pack");
+    }
+    return assetsData.reduceRight((acc, { assetId, medianPrice }) => (0, core_1.beginCell)()
+        .storeUint(assetId, 256)
+        .storeCoins(medianPrice)
+        .storeMaybeRef(acc)
+        .endCell(), null);
+}
+exports.packAssetsData = packAssetsData;
+function packPrices(assetsDataCell, oraclesDataCell) {
+    let pricesCell = (0, core_1.beginCell)()
+        .storeRef(assetsDataCell)
+        .storeRef(oraclesDataCell)
+        .endCell();
+    return pricesCell;
+}
+exports.packPrices = packPrices;
+function createOracleDataProof(oracle, data, signature, assets) {
+    let prunedDict = (0, merkleProof_1.generateMerkleProofDirect)(data.prices, assets, core_1.Dictionary.Keys.BigUint(256));
+    let prunedData = (0, core_1.beginCell)().storeUint(data.timestamp, 32).storeMaybeRef(prunedDict).endCell();
+    let merkleProof = (0, merkleProof_1.convertToMerkleProof)(prunedData);
+    let oracleDataProof = (0, core_1.beginCell)().storeUint(oracle.id, 32).storeRef(merkleProof).storeBuffer(signature).asSlice();
+    return oracleDataProof;
+}
+exports.createOracleDataProof = createOracleDataProof;
+function packOraclesData(oraclesData, assets) {
+    if (oraclesData.length == 0) {
+        throw new Error("no oracles data to pack");
+    }
+    let proofs = oraclesData.sort((d1, d2) => d1.oracle.id - d2.oracle.id).map(({ oracle, data, signature }) => createOracleDataProof(oracle, data, signature, assets));
+    return proofs.reduceRight((acc, val) => (0, core_1.beginCell)().storeSlice(val).storeMaybeRef(acc).endCell(), null);
+}
+exports.packOraclesData = packOraclesData;
+// : String = "api.stardust-mainnet.iotaledger.net"
+function sumDicts(result, addendum) {
+    for (const key of addendum.keys()) {
+        const current = result.get(key);
+        const value = addendum.get(key);
+        if (current === undefined) {
+            result.set(key, value);
+            continue;
+        }
+        result.set(key, current + value);
+    }
+}
+exports.sumDicts = sumDicts;

package/dist/utils/userJettonWallet.d.ts

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

package/dist/utils/userJettonWallet.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUserJettonWallet = void 0;
 const core_1 = require("@ton/core");
+const assets_1 = require("../constants/assets");
 function getUserJettonWallet(ownerAddress, poolAssetConfig) {
+    if (poolAssetConfig.name == 'TON' || poolAssetConfig.assetId === assets_1.UNDEFINED_ASSET.assetId) {
+        throw new Error(`Cant getUserJettonWallet for ${poolAssetConfig.name} asset`);
+    }
     const jettonMasterAddress = poolAssetConfig.jettonMasterAddress;
     const jettonWalletCode = poolAssetConfig.jettonWalletCode;
     if (poolAssetConfig.name === 'USDT') {

package/dist/utils/utils.d.ts

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

package/dist/utils/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTonAsset = void 0;
+function isTonAsset(asset) {
+    return asset.name === 'TON';
+}
+exports.isTonAsset = isTonAsset;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evaafi/sdk",
-  "version": "0.5.4",
+  "version": "0.5.6a",
   "description": "SDK for EVAA contracts",
   "main": "dist/index.js",
   "files": [
@@ -20,7 +20,7 @@
   "devDependencies": {
     "@orbs-network/ton-access": "^2.3.3",
     "@ton/core": "0.56.0",
-    "@tonconnect/sdk": "^3.0.0",
+    "@tonconnect/sdk": "^3.0.5",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.10.4",
     "crypto-js": "^4.2.0",

package/src/api/math.ts

@@ -1,7 +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 { BalanceChangeType, BalanceType, LiquidationData, PredictHealthFactorArgs, UserBalance } from '../types/User';
 import { sha256Hash } from '../utils/sha256BigInt';
+import { TON_MAINNET, UNDEFINED_ASSET } from '../constants/assets';
+import { MAINNET_POOL_CONFIG, TESTNET_POOL_CONFIG } from '..';
 
 export function mulFactor(decimal: bigint, a: bigint, b: bigint): bigint {
     return (a * b) / decimal;
@@ -11,6 +13,12 @@ export function mulDiv(x: bigint, y: bigint, z: bigint): bigint {
     return (x * y) / z;
 }
 
+export function mulDivC(x: bigint, y: bigint, z: bigint): bigint {
+    //const mul = x * y;
+    //return mul / z + (mul % z ? 1n : 0n);
+    return BigInt(Math.ceil(Number(x * y) / Number(z)));
+}
+
 export function bigIntMax(...args: bigint[]): bigint {
     return args.reduce((m, e) => (e > m ? e : m));
 }
@@ -116,6 +124,169 @@ export function calculateAssetInterest(assetConfig: AssetConfig, assetData: Asse
     };
 }
 
+export function checkNotInDebtAtAll(principals: Dictionary<bigint, bigint>): boolean {
+    return principals.values().every(x => x >= 0n);
+}
+
+export function getAgregatedBalances (
+    assetsData: ExtendedAssetsData,
+    assetsConfig: ExtendedAssetsConfig,
+    principals: Dictionary<bigint, bigint>,
+    prices: Dictionary<bigint, bigint>,
+    masterConstants: MasterConstants,
+  ): AgregatedBalances {
+    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)!;
+        // console.log('price', price);
+        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;
+        }
+        // console.log('aggregated', assetId, presentValue(assetData.sRate, assetData.bRate, principal, masterConstants).type, 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
+ */
+export function isV5MainPoolContract(poolConfig: PoolConfig): boolean {
+  if ((poolConfig.masterAddress == MAINNET_POOL_CONFIG.masterAddress && poolConfig.masterVersion == 5) || 
+  (poolConfig.masterAddress == TESTNET_POOL_CONFIG.masterAddress && poolConfig.masterVersion == 5)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * @deprecated The method should be used only for main contract v5
+ */
+export function calculateMaximumWithdrawAmountOld(
+    assetsConfig: ExtendedAssetsConfig,
+    assetsData: ExtendedAssetsData,
+    principals: Dictionary<bigint, bigint>,
+    prices: Dictionary<bigint, bigint>,
+    masterConstants: MasterConstants,
+    assetId: bigint,
+): bigint {
+    let withdrawAmountMax = 0n;
+
+    const assetConfig = assetsConfig.get(assetId) as AssetConfig;
+    const assetData = assetsData.get(assetId) as ExtendedAssetData;
+    const oldPrincipal = principals.get(assetId) as bigint;
+    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) as bigint;
+            const agregatedBalances = getAgregatedBalances(assetsData, assetsConfig, principals, prices, masterConstants);
+            let maxAmountToReclaim = 
+                mulDiv(
+                    agregatedBalances.totalSupply - mulDivC(agregatedBalances.totalBorrow, masterConstants.ASSET_COEFFICIENT_SCALE, assetConfig.collateralFactor),
+                    10n**assetConfig.decimals,
+                    price
+                );
+          
+            withdrawAmountMax = bigIntMin(
+                maxAmountToReclaim,
+                oldPresentValue.amount
+            );
+            //console.log('agregatedBalances', agregatedBalances);
+            //console.log('masterConstants.ASSET_COEFFICIENT_SCALE', masterConstants.ASSET_COEFFICIENT_SCALE);
+            //console.log('assetConfig.collateralFactor', assetConfig.collateralFactor);
+            //console.log('sekay', maxAmountToReclaim, oldPresentValue.amount);
+        }
+    } else {
+        if (!prices.has(assetId)) {
+            return 0n;
+        }
+
+        const price = prices.get(assetId) as bigint;
+
+        return getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants) * (10n ** assetConfig.decimals) / price;
+    }
+
+    return withdrawAmountMax;
+}
+
+export 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 {
+    let withdrawAmountMax = 0n;
+
+    const assetConfig = assetsConfig.get(assetId) as AssetConfig;
+    const assetData = assetsData.get(assetId) as ExtendedAssetData;
+    const oldPrincipal = principals.get(assetId) as bigint;
+
+    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) as bigint;
+
+            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) as bigint;
+
+        return getAvailableToBorrow(assetsConfig, assetsData, principals, prices, masterConstants) * (10n ** assetConfig.decimals) / price;
+    }
+
+    return withdrawAmountMax;
+}
+
 export function getAvailableToBorrow(
     assetsConfig: ExtendedAssetsConfig,
     assetsData: ExtendedAssetsData,
@@ -136,9 +307,10 @@ export function getAvailableToBorrow(
             borrowAmount += (calculatePresentValue(assetData.bRate, -principal, masterConstants) * price) / 10n ** assetConfig.decimals;
         } 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);
         }
     }
 
@@ -164,74 +336,86 @@ export function presentValue(sRate: bigint, bRate: bigint, principalValue: bigin
     }
 }
 
+/**
+ * 
+ * @param assetsConfig 
+ * @param assetsData 
+ * @param principals 
+ * @param prices 
+ * @param poolConfig 
+ * @returns can return UNDEFINED_ASSET if there are no assets
+ */
 export function calculateLiquidationData(
     assetsConfig: ExtendedAssetsConfig,
     assetsData: ExtendedAssetsData,
     principals: Dictionary<bigint, bigint>,
     prices: Dictionary<bigint, bigint>,
-    masterConstants: MasterConstants,
+    poolConfig: PoolConfig,
 ): LiquidationData {
-    let gCollateralValue = 0n;
-    let gCollateralAsset = 0n;
-    let gLoanValue = 0n;
-    let gLoanAsset = 0n;
+    let collateralValue = 0n;
+    let collateralAsset = UNDEFINED_ASSET;
+    let loanValue = 0n;
+    let loanAsset = 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 !== UNDEFINED_ASSET.assetId && totalLimit < totalDebt) {
+        const loanAssetPrice = prices.get(loanAsset.assetId)!;
         const values: bigint[] = [];
-        const gCollateralAssetConfig = assetsConfig.get(gCollateralAsset)!;
-        const gLoanAssetConfig = assetsConfig.get(gLoanAsset)!;
-        const liquidationBonus = gCollateralAssetConfig.liquidationBonus;
-        const loanDecimal = 10n ** gLoanAssetConfig.decimals;
+        const collateralAssetConfig = assetsConfig.get(collateralAsset.assetId)!;
+        const loanAssetConfig = assetsConfig.get(loanAsset.assetId)!;
+        const liquidationBonus = collateralAssetConfig.liquidationBonus;
+        const loanScale = 10n ** loanAssetConfig.decimals;
         values.push(
-            (bigIntMax(gCollateralValue / 2n, bigIntMin(gCollateralValue, 10_000_000_000n)) *
-                loanDecimal *
-                masterConstants.ASSET_COEFFICIENT_SCALE) /
+            (bigIntMax(collateralValue / 2n, bigIntMin(collateralValue, 100_000_000_000n)) *
+                loanScale *
+                poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE) /
                 liquidationBonus /
-                gLoanAssetPrice,
+                loanAssetPrice,
         );
-        values.push((gLoanValue * loanDecimal) / gLoanAssetPrice);
+        values.push((loanValue * loanScale) / loanAssetPrice);
 
         const liquidationAmount = (bigIntMin(...values) as bigint) - 5n;
-        const gCollateralAssetPrice: bigint = prices.get(gCollateralAsset)!;
-        const collateralDecimal = 10n ** gCollateralAssetConfig.decimals;
+        const collateralAssetPrice: bigint = prices.get(collateralAsset.assetId)!;
+        const collateralDecimal = 10n ** collateralAssetConfig.decimals;
         let minCollateralAmount =
-            (((liquidationAmount * gLoanAssetPrice * liquidationBonus) / 10000n) * collateralDecimal) /
-                gCollateralAssetPrice /
-                loanDecimal -
+            (((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,
@@ -242,10 +426,10 @@ export function calculateLiquidationData(
     }
 
     return {
-        greatestCollateralAsset: gCollateralAsset,
-        greatestCollateralValue: gCollateralValue,
-        greatestLoanAsset: gLoanAsset,
-        greatestLoanValue: gLoanValue,
+        greatestCollateralAsset: collateralAsset,
+        greatestCollateralValue: collateralValue,
+        greatestLoanAsset: loanAsset,
+        greatestLoanValue: loanValue,
         totalDebt,
         totalLimit,
         liquidable: false,
@@ -253,7 +437,7 @@ export function calculateLiquidationData(
 }
 
 export function predictHealthFactor(args: PredictHealthFactorArgs): number {
-    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 = sha256Hash(args.tokenSymbol);
     
     const assetConfig = args.assetsConfig.get(tokenHash)!;
@@ -271,13 +455,13 @@ export function predictHealthFactor(args: PredictHealthFactorArgs): number {
 
     if (currentAmount != null && currentAmount != 0n) { 
         if (changeType == 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 == BalanceChangeType.Repay) {
             totalBorrow -= currentBalance;
         } else if (changeType == 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 == 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) {