@evaafi/sdk 0.6.1 → 0.6.2-b

package/dist/prices/sources/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Backend"), exports);
+__exportStar(require("./Iota"), exports);
+__exportStar(require("./Icp"), exports);
+__exportStar(require("./PriceSource"), exports);

package/dist/prices/utils.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { Cell, Dictionary, Slice } from "@ton/core";
+import { OraclePricesData, PriceData, PriceSource, PriceSourcesConfig, RawPriceData } from "..";
+import { Oracle, OracleNFT, PoolConfig } from "../types/Master";
+export declare function verifyPricesTimestamp(): (priceData: RawPriceData) => boolean;
+export declare function verifyPricesSign(nfts: OracleNFT[]): (priceData: RawPriceData) => boolean;
+export declare function getMedianPrice(pricesData: PriceData[], asset: bigint): bigint | null;
+export declare function packAssetsData(assetsData: {
+    assetId: bigint;
+    medianPrice: bigint;
+}[]): Cell;
+export declare function packPrices(assetsDataCell: Cell, oraclesDataCell: Cell): Cell;
+export declare function createOracleDataProof(oracle: Oracle, data: OraclePricesData, signature: Buffer, assets: Array<bigint>): Slice;
+export declare function packOraclesData(oraclesData: {
+    oracle: Oracle;
+    data: OraclePricesData;
+    signature: Buffer;
+}[], assets: Array<bigint>): Cell;
+export declare function sumDicts(result: Dictionary<bigint, bigint>, addendum: Dictionary<bigint, bigint>): void;
+export declare function generatePriceSources(config?: PriceSourcesConfig, nfts?: OracleNFT[]): PriceSource[];
+export declare function collectAndFilterPrices(priceSource: PriceSource, poolConfig: PoolConfig): Promise<RawPriceData[]>;
+export declare function unpackMedianPrices(pricesCell: Cell): Dictionary<bigint, bigint> | undefined;
+export declare function verifyRawPriceDataSign(priceData: RawPriceData): boolean;

package/dist/prices/utils.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyRawPriceDataSign = exports.unpackMedianPrices = exports.collectAndFilterPrices = exports.generatePriceSources = exports.sumDicts = exports.packOraclesData = exports.createOracleDataProof = exports.packPrices = exports.packAssetsData = exports.getMedianPrice = exports.verifyPricesSign = exports.verifyPricesTimestamp = void 0;
+const core_1 = require("@ton/core");
+const __1 = require("..");
+const merkleProof_1 = require("../utils/merkleProof");
+const crypto_1 = require("@ton/crypto");
+function verifyPricesTimestamp() {
+    return function (priceData) {
+        const timestamp = Date.now() / 1000;
+        const pricesTime = priceData.timestamp;
+        //console.debug('timestamp - pricesTime, pricesTime', timestamp - pricesTime, pricesTime);
+        return timestamp - pricesTime < __1.TTL_ORACLE_DATA_SEC;
+    };
+}
+exports.verifyPricesTimestamp = verifyPricesTimestamp;
+function verifyPricesSign(nfts) {
+    return function (priceData) {
+        if (nfts.findIndex(x => x.pubkey.equals(priceData.pubkey)) == -1) {
+            //console.debug('[verifyPricesSign] nft not found');
+            return false;
+        }
+        return verifyRawPriceDataSign(priceData);
+    };
+}
+exports.verifyPricesSign = verifyPricesSign;
+/* export function verifyPricesAssets(assets: PoolAssetsConfig) {
+    return function(priceData: RawPriceData): boolean {
+        for (const asset of assets) {
+            if(!priceData.dict.has(asset.assetId)) {
+                return false;
+            }
+        }
+        return true;
+    }
+} */
+function getMedianPrice(pricesData, asset) {
+    try {
+        const usingPrices = pricesData.filter(x => x.dict.has(asset));
+        const sorted = usingPrices.map(x => x.dict.get(asset)).sort((a, b) => Number(a) - Number(b));
+        if (sorted.length == 0) {
+            return null;
+        }
+        const mid = Math.floor(sorted.length / 2);
+        if (sorted.length % 2 === 0) {
+            return (sorted[mid - 1] + sorted[mid]) / 2n;
+        }
+        else {
+            return sorted[mid];
+        }
+    }
+    catch {
+        return null;
+    }
+}
+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;
+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;
+function generatePriceSources(config = __1.DefaultPriceSourcesConfig, nfts = __1.MAINNET_POOL_CONFIG.oracles) {
+    let result = config.backendEndpoints.map(x => new __1.BackendPriceSource(x, nfts));
+    result.push(...config.icpEndpoints.map(x => new __1.IcpPriceSource(x, nfts)));
+    result.push(...config.iotaEndpoints.map(x => new __1.IotaPriceSource(x, nfts)));
+    return result;
+}
+exports.generatePriceSources = generatePriceSources;
+async function collectAndFilterPrices(priceSource, poolConfig) {
+    const prices = await priceSource.getPrices();
+    //console.debug('[FILTERING] before filtering prices len ', priceSource.sourceName, prices.length);
+    return await (async () => {
+        const acceptedPrices = prices.filter(price => verifyPricesTimestamp()(price) && verifyPricesSign(poolConfig.oracles)(price));
+        //console.debug('[FILTERING] after filtering prices len ', priceSource.sourceName, acceptedPrices.length);
+        if (acceptedPrices.length < poolConfig.minimalOracles) {
+            throw new Error("Prices are outdated");
+        }
+        return acceptedPrices;
+    })();
+}
+exports.collectAndFilterPrices = collectAndFilterPrices;
+function unpackMedianPrices(pricesCell) {
+    if (!pricesCell)
+        return undefined;
+    const slice = pricesCell.beginParse();
+    let assetCell = slice.loadRef();
+    const res = core_1.Dictionary.empty();
+    while (assetCell != core_1.Cell.EMPTY && assetCell !== null) {
+        const slice = assetCell.beginParse();
+        const assetId = slice.loadUintBig(256);
+        const medianPrice = slice.loadCoins();
+        res.set(assetId, medianPrice);
+        assetCell = slice.loadMaybeRef();
+    }
+    return res;
+}
+exports.unpackMedianPrices = unpackMedianPrices;
+function verifyRawPriceDataSign(priceData) {
+    const message = priceData.dataCell.refs[0].hash();
+    const signature = priceData.signature;
+    const publicKey = priceData.pubkey;
+    const valid = (0, crypto_1.signVerify)(message, signature, publicKey);
+    //console.debug('[verifyRawPriceDataSign] sign is valid:', valid);
+    return valid;
+}
+exports.verifyRawPriceDataSign = verifyRawPriceDataSign;

package/dist/types/Master.d.ts

@@ -80,7 +80,7 @@ export type AssetData = {
     balance: bigint;
     trackingSupplyIndex: bigint;
     trackingBorrowIndex: bigint;
-    awaitedSupply?: bigint;
+    awaitedSupply: bigint;
 };
 export type AssetInterest = {
     supplyInterest: bigint;
@@ -112,6 +112,7 @@ export type AgregatedBalances = {
 export type OracleNFT = {
     id: number;
     address: string;
+    pubkey: Buffer;
 };
 export type Oracle = {
     id: number;

package/dist/types/User.d.ts

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

package/dist/utils/userJettonWallet.js

@@ -3,54 +3,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUserJettonWallet = void 0;
 const core_1 = require("@ton/core");
 const assets_1 = require("../constants/assets");
+function getUserJettonData(ownerAddress, assetName, jettonWalletCode, jettonMasterAddress) {
+    switch (assetName) {
+        case 'uTON':
+            return (0, core_1.beginCell)()
+                .storeCoins(0)
+                .storeUint(0, 64)
+                .storeAddress(ownerAddress)
+                .storeAddress(jettonMasterAddress)
+                .storeRef(jettonWalletCode)
+                .endCell();
+        case 'DOGS':
+        case 'NOT':
+        case 'USDT':
+            return (0, core_1.beginCell)()
+                .storeUint(0, 4)
+                .storeCoins(0)
+                .storeAddress(ownerAddress)
+                .storeAddress(jettonMasterAddress)
+                .endCell();
+        case 'tsTON':
+            return (0, core_1.beginCell)()
+                .storeCoins(0)
+                .storeAddress(ownerAddress)
+                .storeAddress(jettonMasterAddress)
+                .storeRef(jettonWalletCode)
+                .storeCoins(0)
+                .storeUint(0, 48)
+                .endCell();
+        default:
+            return (0, core_1.beginCell)().storeCoins(0)
+                .storeAddress(ownerAddress)
+                .storeAddress(jettonMasterAddress)
+                .storeRef(jettonWalletCode)
+                .endCell();
+    }
+}
 function getUserJettonWallet(ownerAddress, poolAssetConfig) {
-    if (poolAssetConfig.name == 'TON' || poolAssetConfig.assetId === assets_1.UNDEFINED_ASSET.assetId) {
+    const assetName = poolAssetConfig.name;
+    if (assetName == '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') {
+    let jettonWalletCode = poolAssetConfig.jettonWalletCode;
+    if (assetName === 'USDT' || assetName === '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)()
-            .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());
+        jettonWalletCode = new core_1.Cell({ exotic: true, bits: lib_prep.bits, refs: lib_prep.refs });
     }
-    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 jettonData = getUserJettonData(ownerAddress, assetName, jettonWalletCode, poolAssetConfig.jettonMasterAddress);
     const stateInit = (0, core_1.beginCell)()
         .store((0, core_1.storeStateInit)({
         code: jettonWalletCode,

package/dist/utils/utils.d.ts

@@ -1,3 +1,4 @@
 import { PoolAssetConfig } from "../types/Master";
 export declare function isTonAsset(asset: PoolAssetConfig): boolean;
 export declare function isTonAssetId(assetId: bigint): boolean;
+export declare function delay(ms: number): Promise<unknown>;

package/dist/utils/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTonAssetId = exports.isTonAsset = void 0;
+exports.delay = exports.isTonAssetId = exports.isTonAsset = void 0;
 const assets_1 = require("../constants/assets");
 function isTonAsset(asset) {
     return asset.name === 'TON';
@@ -10,3 +10,7 @@ function isTonAssetId(assetId) {
     return assetId === assets_1.ASSET_ID.TON;
 }
 exports.isTonAssetId = isTonAssetId;
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.delay = delay;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evaafi/sdk",
-  "version": "0.6.1",
+  "version": "0.6.2-b",
   "description": "The EVAA SDK is designed to easily integrate with the EVAA lending protocol on TON blockchain.",
   "main": "dist/index.js",
   "files": [
@@ -8,7 +8,8 @@
     "src"
   ],
   "scripts": {
-    "build": "tsc --declaration"
+    "build": "tsc --declaration",
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -20,15 +21,16 @@
   "devDependencies": {
     "@orbs-network/ton-access": "^2.3.3",
     "@ton/core": "0.56.0",
-    "@ton/crypto": "^3.3.0",
-    "@tonconnect/sdk": "^3.0.5",
+    "@ton/crypto": "3.3.0",
+    "@tonconnect/sdk": "3.0.5",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.10.4",
-    "crypto-js": "^4.2.0",
-    "prettier": "^3.2.4",
+    "crypto-js": "4.2.0",
+    "prettier": "3.2.4",
     "ts-jest": "^29.2.4",
     "ts-node": "^10.9.1",
-    "typescript": "^5.3.3"
+    "typedoc": "0.27.4",
+    "typescript": "5.3.3"
   },
   "peerDependencies": {
     "@ton/core": ">=0.56.0",
@@ -36,7 +38,7 @@
     "crypto-js": ">=4.2.0"
   },
   "dependencies": {
-    "@ton/ton": "^14.0.0",
-    "dotenv": "^16.4.5"
+    "@ton/ton": "14.0.0",
+    "dotenv": "16.4.5"
   }
 }

package/src/api/liquidation.ts

@@ -179,7 +179,6 @@ export function calculateLiquidationAmounts(
 
     const loanValue = toAssetWorth(loanInfo.balance, loanInfo.scale, loanInfo.price);
     const baseLiquidationValue = BigMath.min(
-        // deductReserve(loanValue, reserveFactor, reserveFactorScale),
         loanValue,
         deductLiquidationBonus(allowedCollateralValue, liquidationBonus, liquidationBonusScale)
     );

package/src/api/math.ts

@@ -15,6 +15,7 @@ import {
     BalanceType,
     HealthParamsArgs,
     LiquidationData,
+    PredictAPYArgs,
     PredictHealthFactorArgs,
     UserBalance
 } from '../types/User';
@@ -109,9 +110,28 @@ export function calculateAssetData(
     };
 }
 
-export function calculateAssetInterest(assetConfig: AssetConfig, assetData: AssetData, masterConstants: MasterConstants): AssetInterest {
+export function calculateAssetInterest(
+    assetConfig: AssetConfig,
+    assetData: AssetData,
+    masterConstants: MasterConstants
+): AssetInterest {
     const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply, masterConstants);
     const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow, masterConstants);
+
+    return calculateInterestWithSupplyBorrow(
+        totalSupply,
+        totalBorrow,
+        assetConfig,
+        masterConstants
+    );
+}
+
+export function calculateInterestWithSupplyBorrow(
+    totalSupply: bigint,
+    totalBorrow: bigint,
+    assetConfig: AssetConfig,
+    masterConstants: MasterConstants
+): AssetInterest {
     let utilization = 0n;
     let supplyInterest = 0n;
     let borrowInterest = 0n;
@@ -147,6 +167,7 @@ export function calculateAssetInterest(assetConfig: AssetConfig, assetData: Asse
     };
 }
 
+
 export function checkNotInDebtAtAll(principals: Dictionary<bigint, bigint>): boolean {
     return principals.values().every(x => x >= 0n);
 }
@@ -170,13 +191,12 @@ export function getAgregatedBalances(
             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 };
@@ -251,10 +271,19 @@ export function getAvailableToBorrow(
     let borrowAmount = 0n;
 
     for (const assetID of principals.keys()) {
+        const principal = principals.get(assetID) as bigint;
+        
+        if (principal == 0n) {
+            continue;
+        }
+
+        if (!prices.has(assetID)) {
+            return 0n;
+        }
+
         const assetConfig = assetsConfig.get(assetID) as AssetConfig;
         const assetData = assetsData.get(assetID) as ExtendedAssetData;
         const price = prices.get(assetID) as bigint;
-        const principal = principals.get(assetID) as bigint;
 
         if (principal < 0n) {
             borrowAmount += mulDiv(calculatePresentValue(assetData.bRate, -principal, masterConstants), price, 10n ** assetConfig.decimals);
@@ -465,7 +494,6 @@ export function predictHealthFactor(args: PredictHealthFactorArgs): number {
 
     const assetConfig = args.assetsConfig.get(assetId)!;
     const assetPrice = Number(args.prices.get(assetId)!);
-const assetData = args.assetsData.get(assetId)!;
 
     let totalLimit = Number(healthParams.totalLimit);
     let totalBorrow = Number(healthParams.totalDebt);
@@ -494,3 +522,36 @@ const assetData = args.assetsData.get(assetId)!;
 
     return Math.min(Math.max(1 - totalBorrow / totalLimit, 0), 1);  // let's limit a result to zero below and one above
 }
+
+/**
+ * Predicts how APY will change as a result of one of the actions Borrow, Supply, Withdraw or Repay. 
+ *
+ * Used on the front-end. 
+ *
+ * @returns Estimated APYs for Supply and Borrow
+ */
+export function predictAPY(args: PredictAPYArgs): AssetInterest {
+    const assetConfig = args.assetConfig;
+    const assetData = args.assetData;
+    const masterConstants = args.masterConstants;
+
+    let totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply, masterConstants);
+    let totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow, masterConstants);
+
+    const currentAmount = args.amount;
+    const changeType = args.balanceChangeType;
+
+    if (currentAmount != null && currentAmount != 0n) {
+        if (changeType == BalanceChangeType.Borrow) {
+            totalBorrow += currentAmount;
+        } else if (changeType == BalanceChangeType.Repay) {
+            totalBorrow -= currentAmount;
+        } else if (changeType == BalanceChangeType.Withdraw) {
+            totalSupply -= currentAmount;
+        } else if (changeType == BalanceChangeType.Supply) {
+            totalSupply += currentAmount;
+        }
+    }
+
+    return calculateInterestWithSupplyBorrow(totalSupply, totalBorrow, assetConfig, masterConstants);
+}