@evaafi/sdk 0.2.0

package/README.md

@@ -0,0 +1,7 @@
+# EVAA SDK
+
+The EVAA SDK is designed to easily integrate with EVAA lending protocol.
+
+## Documentation
+
+You can find the documentation in the [docs](./docs) folder.

package/dist/api/helpers.d.ts

@@ -0,0 +1,8 @@
+import { Cell, Slice } from '@ton/core';
+declare class MyCell extends Cell {
+    toString(): string;
+    hashBigInt(): bigint;
+}
+export declare function loadMyRef(slice: Slice): MyCell;
+export declare function loadMaybeMyRef(slice: Slice): Cell | null;
+export {};

package/dist/api/helpers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMaybeMyRef = exports.loadMyRef = void 0;
+const core_1 = require("@ton/core");
+class MyCell extends core_1.Cell {
+    toString() {
+        return this.hashBigInt().toString();
+    }
+    hashBigInt() {
+        return BigInt('0x' + this.hash().toString('hex'));
+    }
+}
+function loadMyRef(slice) {
+    const cell = slice.loadRef();
+    return new MyCell({
+        exotic: cell.isExotic,
+        bits: cell.bits,
+        refs: cell.refs,
+    });
+}
+exports.loadMyRef = loadMyRef;
+function loadMaybeMyRef(slice) {
+    const cell = slice.loadMaybeRef();
+    if (cell === null) {
+        return null;
+    }
+    return new MyCell({
+        exotic: cell.isExotic,
+        bits: cell.bits,
+        refs: cell.refs,
+    });
+}
+exports.loadMaybeMyRef = loadMaybeMyRef;

package/dist/api/math.d.ts

@@ -0,0 +1,20 @@
+import { AssetConfig, AssetData, AssetInterest, ExtendedAssetData } from '../types/Master';
+import { Dictionary } from '@ton/core';
+import { LiquidationData, 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 bigIntMax(...args: bigint[]): bigint;
+export declare function bigIntMin(...args: bigint[]): bigint;
+export declare function calculatePresentValue(index: bigint, principalValue: bigint): bigint;
+export declare function calculateCurrentRates(assetConfig: AssetConfig, assetData: AssetData): {
+    sRate: bigint;
+    bRate: bigint;
+    supplyInterest: bigint;
+    borrowInterest: bigint;
+    now: bigint;
+};
+export declare function calculateAssetData(assetsConfigDict: Dictionary<bigint, AssetConfig>, assetsDataDict: Dictionary<bigint, AssetData>, assetId: bigint): ExtendedAssetData;
+export declare function calculateAssetInterest(assetConfig: AssetConfig, assetData: AssetData): AssetInterest;
+export declare function getAvailableToBorrow(assetsConfig: Dictionary<bigint, AssetConfig>, assetsData: Dictionary<bigint, ExtendedAssetData>, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>): bigint;
+export declare function presentValue(sRate: bigint, bRate: bigint, principalValue: bigint): UserBalance;
+export declare function calculateLiquidationData(assetsConfig: Dictionary<bigint, AssetConfig>, assetsData: Dictionary<bigint, ExtendedAssetData>, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>): LiquidationData;

package/dist/api/math.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateLiquidationData = exports.presentValue = exports.getAvailableToBorrow = exports.calculateAssetInterest = exports.calculateAssetData = exports.calculateCurrentRates = exports.calculatePresentValue = exports.bigIntMin = exports.bigIntMax = exports.mulDiv = exports.mulFactor = void 0;
+const constants_1 = require("../constants");
+const User_1 = require("../types/User");
+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 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) {
+    return (principalValue * index) / constants_1.MASTER_CONSTANTS.FACTOR_SCALE;
+}
+exports.calculatePresentValue = calculatePresentValue;
+function calculateCurrentRates(assetConfig, assetData) {
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const timeElapsed = now - assetData.lastAccural;
+    const { supplyInterest, borrowInterest } = calculateAssetInterest(assetConfig, assetData);
+    if (timeElapsed > 0) {
+        const updatedSRate = assetData.sRate + mulFactor(constants_1.MASTER_CONSTANTS.FACTOR_SCALE, assetData.sRate, supplyInterest * timeElapsed);
+        const updatedBRate = assetData.bRate + mulFactor(constants_1.MASTER_CONSTANTS.FACTOR_SCALE, assetData.bRate, borrowInterest * timeElapsed);
+        return {
+            sRate: updatedSRate,
+            bRate: updatedBRate,
+            supplyInterest,
+            borrowInterest,
+            now,
+        };
+    }
+    return {
+        sRate: assetData.sRate,
+        bRate: assetData.bRate,
+        supplyInterest,
+        borrowInterest,
+        now,
+    };
+}
+exports.calculateCurrentRates = calculateCurrentRates;
+function calculateAssetData(assetsConfigDict, assetsDataDict, assetId) {
+    const config = assetsConfigDict.get(assetId); // maybe it's a huge mistake could be
+    const data = assetsDataDict.get(assetId);
+    if (!data || !config) {
+        throw new Error('Asset Data or Config is not accessible');
+    }
+    const { sRate, bRate, supplyInterest, borrowInterest, now } = calculateCurrentRates(config, data);
+    data.sRate = sRate || 0n;
+    data.bRate = bRate || 0n;
+    data.lastAccural = now;
+    const supplyApy = (1 + (Number(supplyInterest) / 1e12) * 24 * 3600) ** 365 - 1;
+    const borrowApy = (1 + (Number(borrowInterest) / 1e12) * 24 * 3600) ** 365 - 1;
+    return {
+        ...data,
+        ...{ supplyInterest, borrowInterest },
+        ...{ supplyApy, borrowApy },
+    };
+}
+exports.calculateAssetData = calculateAssetData;
+function calculateAssetInterest(assetConfig, assetData) {
+    const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply);
+    const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow);
+    let utilization = 0n;
+    let supplyInterest = 0n;
+    let borrowInterest = 0n;
+    if (totalSupply !== 0n) {
+        utilization = (totalBorrow * constants_1.MASTER_CONSTANTS.FACTOR_SCALE) / totalSupply;
+    }
+    if (utilization <= assetConfig.targetUtilization) {
+        borrowInterest =
+            assetConfig.baseBorrowRate +
+                mulFactor(constants_1.MASTER_CONSTANTS.FACTOR_SCALE, assetConfig.borrowRateSlopeLow, utilization);
+    }
+    else {
+        borrowInterest =
+            assetConfig.baseBorrowRate +
+                mulFactor(constants_1.MASTER_CONSTANTS.FACTOR_SCALE, assetConfig.borrowRateSlopeLow, assetConfig.targetUtilization) +
+                mulFactor(constants_1.MASTER_CONSTANTS.FACTOR_SCALE, assetConfig.borrowRateSlopeHigh, utilization - assetConfig.targetUtilization);
+    }
+    const reserveFactor = 10n;
+    const reserveScale = 100n;
+    supplyInterest = mulDiv(mulDiv(borrowInterest, utilization, constants_1.MASTER_CONSTANTS.FACTOR_SCALE), reserveScale - reserveFactor, reserveScale);
+    return {
+        supplyInterest,
+        borrowInterest,
+    };
+}
+exports.calculateAssetInterest = calculateAssetInterest;
+function getAvailableToBorrow(assetsConfig, assetsData, principals, prices) {
+    let borrowLimit = 0n;
+    let borrowAmount = 0n;
+    for (const assetID of principals.keys()) {
+        const assetConfig = assetsConfig.get(assetID);
+        const assetData = assetsData.get(assetID);
+        const price = prices.get(assetID);
+        const principal = principals.get(assetID);
+        if (principal < 0) {
+            borrowAmount += (calculatePresentValue(assetData.bRate, -principal) * price) / 10n ** assetConfig.decimals;
+        }
+        else if (principal > 0) {
+            borrowLimit +=
+                (calculatePresentValue(assetData.sRate, principal) * price * assetConfig.collateralFactor) /
+                    10n ** assetConfig.decimals /
+                    constants_1.MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE;
+        }
+    }
+    return borrowLimit - borrowAmount;
+}
+exports.getAvailableToBorrow = getAvailableToBorrow;
+function presentValue(sRate, bRate, principalValue) {
+    if (principalValue > 0) {
+        return {
+            amount: calculatePresentValue(sRate, principalValue),
+            type: User_1.BalanceType.supply,
+        };
+    }
+    else if (principalValue < 0) {
+        return {
+            amount: calculatePresentValue(bRate, -principalValue),
+            type: User_1.BalanceType.borrow,
+        };
+    }
+    else {
+        return {
+            amount: 0n,
+            type: undefined,
+        };
+    }
+}
+exports.presentValue = presentValue;
+function calculateLiquidationData(assetsConfig, assetsData, principals, prices) {
+    let gCollateralValue = 0n;
+    let gCollateralAsset = 0n;
+    let gLoanValue = 0n;
+    let gLoanAsset = 0n;
+    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);
+        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) / constants_1.MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE;
+            if (assetWorth > gCollateralValue) {
+                gCollateralValue = assetWorth;
+                gCollateralAsset = key;
+            }
+        }
+        else if (balance < 0) {
+            const assetWorth = (-balance * prices.get(key)) / 10n ** assetConfig.decimals;
+            totalDebt += assetWorth;
+            if (assetWorth > gLoanValue) {
+                gLoanValue = assetWorth;
+                gLoanAsset = key;
+            }
+        }
+    }
+    if (totalLimit < totalDebt) {
+        const gLoanAssetPrice = prices.get(gLoanAsset);
+        const values = [];
+        const gCollateralAssetConfig = assetsConfig.get(gCollateralAsset);
+        const gLoanAssetConfig = assetsConfig.get(gLoanAsset);
+        const liquidationBonus = gLoanAssetConfig.liquidationBonus;
+        const loanDecimal = 10n ** gLoanAssetConfig.decimals;
+        values.push((bigIntMax(gCollateralValue / 2n, bigIntMin(gCollateralValue, 10000000000n)) *
+            loanDecimal *
+            constants_1.MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE) /
+            liquidationBonus /
+            gLoanAssetPrice);
+        values.push((gLoanValue * loanDecimal) / gLoanAssetPrice);
+        const liquidationAmount = bigIntMin(...values) - 5n;
+        const gCollateralAssetPrice = prices.get(gCollateralAsset);
+        const collateralDecimal = 10n ** gCollateralAssetConfig.decimals;
+        let minCollateralAmount = (((liquidationAmount * gLoanAssetPrice * liquidationBonus) / 10000n) * collateralDecimal) /
+            gCollateralAssetPrice /
+            loanDecimal -
+            10n;
+        minCollateralAmount = (minCollateralAmount * 97n) / 100n;
+        if (minCollateralAmount / collateralDecimal >= 1n) {
+            return {
+                greatestCollateralAsset: gCollateralAsset,
+                greatestCollateralValue: gCollateralValue,
+                greatestLoanAsset: gLoanAsset,
+                greatestLoanValue: gLoanValue,
+                totalDebt,
+                totalLimit,
+                liquidable: true,
+                liquidationAmount,
+                minCollateralAmount,
+            };
+        }
+    }
+    return {
+        greatestCollateralAsset: gCollateralAsset,
+        greatestCollateralValue: gCollateralValue,
+        greatestLoanAsset: gLoanAsset,
+        greatestLoanValue: gLoanValue,
+        totalDebt,
+        totalLimit,
+        liquidable: false,
+    };
+}
+exports.calculateLiquidationData = calculateLiquidationData;

package/dist/api/parser.d.ts

@@ -0,0 +1,8 @@
+import { Dictionary, DictionaryValue } from '@ton/core';
+import { AssetConfig, AssetData, ExtendedAssetData, MasterData } 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): MasterData;
+export declare function parseUserLiteData(userDataBOC: string, assetsData: Dictionary<bigint, ExtendedAssetData>, assetsConfig: Dictionary<bigint, AssetConfig>): UserLiteData;
+export declare function parseUserData(userLiteData: UserLiteData, assetsData: Dictionary<bigint, ExtendedAssetData>, assetsConfig: Dictionary<bigint, AssetConfig>, prices: Dictionary<bigint, bigint>): UserData;

package/dist/api/parser.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUserData = exports.parseUserLiteData = exports.parseMasterData = exports.createAssetConfig = exports.createAssetData = void 0;
+const core_1 = require("@ton/core");
+const constants_1 = require("../constants");
+const math_1 = require("./math");
+const helpers_1 = require("./helpers");
+const User_1 = require("../types/User");
+function createAssetData() {
+    return {
+        serialize: (src, buidler) => {
+            buidler.storeUint(src.s_rate, 64);
+            buidler.storeUint(src.b_rate, 64);
+            buidler.storeUint(src.totalSupply, 64);
+            buidler.storeUint(src.totalBorrow, 64);
+            buidler.storeUint(src.lastAccural, 32);
+            buidler.storeUint(src.balance, 64);
+        },
+        parse: (src) => {
+            const sRate = BigInt(src.loadInt(64));
+            const bRate = BigInt(src.loadInt(64));
+            const totalSupply = BigInt(src.loadInt(64));
+            const totalBorrow = BigInt(src.loadInt(64));
+            const lastAccural = BigInt(src.loadInt(32));
+            const balance = BigInt(src.loadInt(64));
+            return { sRate, bRate, totalSupply, totalBorrow, lastAccural, balance };
+        },
+    };
+}
+exports.createAssetData = createAssetData;
+function createAssetConfig() {
+    return {
+        serialize: (src, builder) => {
+            builder.storeUint(src.oracle, 256);
+            builder.storeUint(src.decimals, 8);
+            const refBuild = (0, core_1.beginCell)();
+            refBuild.storeUint(src.collateralFactor, 16);
+            refBuild.storeUint(src.liquidationThreshold, 16);
+            refBuild.storeUint(src.liquidationPenalty, 16);
+            refBuild.storeUint(src.baseBorrowRate, 64);
+            refBuild.storeUint(src.borrowRateSlopeLow, 64);
+            refBuild.storeUint(src.borrowRateSlopeHigh, 64);
+            refBuild.storeUint(src.supplyRateSlopeLow, 64);
+            refBuild.storeUint(src.supplyRateSlopeHigh, 64);
+            refBuild.storeUint(src.targetUtilization, 64);
+            refBuild.storeUint(src.originationFee, 64);
+            builder.storeRef(refBuild.endCell());
+        },
+        parse: (src) => {
+            const oracle = src.loadUintBig(256);
+            const decimals = BigInt(src.loadUint(8));
+            const ref = src.loadRef().beginParse();
+            const collateralFactor = BigInt(ref.loadUint(16));
+            const liquidationThreshold = BigInt(ref.loadUint(16));
+            const liquidationBonus = BigInt(ref.loadUint(16));
+            const baseBorrowRate = BigInt(ref.loadUint(64));
+            const borrowRateSlopeLow = BigInt(ref.loadUint(64));
+            const borrowRateSlopeHigh = BigInt(ref.loadUint(64));
+            const supplyRateSlopeLow = BigInt(ref.loadUint(64));
+            const supplyRateSlopeHigh = BigInt(ref.loadUint(64));
+            const targetUtilization = BigInt(ref.loadUint(64));
+            const originationFee = BigInt(ref.loadUint(64));
+            return {
+                oracle,
+                decimals,
+                collateralFactor,
+                liquidationThreshold,
+                liquidationBonus,
+                baseBorrowRate,
+                borrowRateSlopeLow,
+                borrowRateSlopeHigh,
+                supplyRateSlopeLow,
+                supplyRateSlopeHigh,
+                targetUtilization,
+                originationFee,
+            };
+        },
+    };
+}
+exports.createAssetConfig = createAssetConfig;
+function parseMasterData(masterDataBOC) {
+    const masterSlice = core_1.Cell.fromBase64(masterDataBOC).beginParse();
+    const meta = masterSlice.loadRef().beginParse().loadStringTail();
+    const upgradeConfigParser = masterSlice.loadRef().beginParse();
+    const upgradeConfig = {
+        masterCodeVersion: Number(upgradeConfigParser.loadCoins()),
+        userCodeVersion: Number(upgradeConfigParser.loadCoins()),
+        timeout: upgradeConfigParser.loadUint(32),
+        updateTime: upgradeConfigParser.loadUint(64),
+        freezeTime: upgradeConfigParser.loadUint(64),
+        userCode: (0, helpers_1.loadMyRef)(upgradeConfigParser),
+        blankCode: (0, helpers_1.loadMyRef)(upgradeConfigParser),
+        newMasterCode: (0, helpers_1.loadMaybeMyRef)(upgradeConfigParser),
+        newUserCode: (0, helpers_1.loadMaybeMyRef)(upgradeConfigParser),
+    };
+    upgradeConfigParser.endParse();
+    const masterConfigSlice = masterSlice.loadRef().beginParse();
+    const assetsConfigDict = masterConfigSlice.loadDict(core_1.Dictionary.Keys.BigUint(256), createAssetConfig());
+    const assetsDataDict = masterSlice.loadDict(core_1.Dictionary.Keys.BigUint(256), createAssetData());
+    const assetsExtendedData = core_1.Dictionary.empty();
+    const assetsReserves = core_1.Dictionary.empty();
+    const apy = {
+        supply: core_1.Dictionary.empty(),
+        borrow: core_1.Dictionary.empty(),
+    };
+    for (const [tokenSymbol, assetID] of Object.entries(constants_1.ASSET_ID)) {
+        const assetData = (0, math_1.calculateAssetData)(assetsConfigDict, assetsDataDict, assetID);
+        assetsExtendedData.set(assetID, assetData);
+    }
+    const masterConfig = {
+        ifActive: masterConfigSlice.loadInt(8),
+        admin: masterConfigSlice.loadAddress(),
+        adminPK: masterConfigSlice.loadBuffer(64),
+        tokenKeys: (0, helpers_1.loadMaybeMyRef)(masterConfigSlice),
+        walletToMaster: (0, helpers_1.loadMaybeMyRef)(masterConfigSlice),
+    };
+    masterConfigSlice.endParse();
+    for (const [_, assetID] of Object.entries(constants_1.ASSET_ID)) {
+        const assetData = assetsExtendedData.get(assetID);
+        const totalSupply = (0, math_1.calculatePresentValue)(assetData.sRate, assetData.totalSupply);
+        const totalBorrow = (0, math_1.calculatePresentValue)(assetData.bRate, assetData.totalBorrow);
+        assetsReserves.set(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);
+    }
+    return {
+        meta: meta,
+        upgradeConfig: upgradeConfig,
+        masterConfig: masterConfig,
+        assetsConfig: assetsConfigDict,
+        assetsData: assetsExtendedData,
+        assetsReserves: assetsReserves,
+        apy: apy,
+    };
+}
+exports.parseMasterData = parseMasterData;
+function parseUserLiteData(userDataBOC, assetsData, assetsConfig) {
+    const userSlice = core_1.Cell.fromBase64(userDataBOC).beginParse();
+    const codeVersion = userSlice.loadCoins();
+    const masterAddress = userSlice.loadAddress();
+    const userAddress = userSlice.loadAddress();
+    const principalsDict = userSlice.loadDict(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.BigInt(64));
+    const userState = userSlice.loadInt(64);
+    const trackingSupplyIndex = userSlice.loadUintBig(64);
+    const trackingBorrowIndex = userSlice.loadUintBig(64);
+    const dutchAuctionStart = userSlice.loadUint(32);
+    const backupCell = (0, helpers_1.loadMyRef)(userSlice);
+    userSlice.endParse();
+    const userBalances = core_1.Dictionary.empty();
+    for (const [_, assetID] of Object.entries(constants_1.ASSET_ID)) {
+        const assetData = assetsData.get(assetID);
+        const assetConfig = assetsConfig.get(assetID);
+        const balance = (0, math_1.presentValue)(assetData.sRate, assetData.bRate, principalsDict.get(assetID) || 0n);
+        userBalances.set(assetID, balance);
+    }
+    return {
+        type: 'active',
+        codeVersion: Number(codeVersion),
+        masterAddress: masterAddress,
+        ownerAddress: userAddress,
+        principals: principalsDict,
+        state: userState,
+        balances: userBalances,
+        trackingSupplyIndex: trackingSupplyIndex,
+        trackingBorrowIndex: trackingBorrowIndex,
+        dutchAuctionStart: dutchAuctionStart,
+        backupCell: backupCell,
+    };
+}
+exports.parseUserLiteData = parseUserLiteData;
+function parseUserData(userLiteData, assetsData, assetsConfig, prices) {
+    const withdrawalLimits = core_1.Dictionary.empty();
+    const borrowLimits = core_1.Dictionary.empty();
+    let supplyBalance = 0n;
+    let borrowBalance = 0n;
+    for (const [_, assetID] of Object.entries(constants_1.ASSET_ID)) {
+        const assetData = assetsData.get(assetID);
+        const assetConfig = assetsConfig.get(assetID);
+        const balance = (0, math_1.presentValue)(assetData.sRate, assetData.bRate, userLiteData.principals.get(assetID) || 0n);
+        userLiteData.balances.set(assetID, balance);
+    }
+    for (const [_, assetID] of Object.entries(constants_1.ASSET_ID)) {
+        const assetConfig = assetsConfig.get(assetID);
+        const balance = userLiteData.balances.get(assetID);
+        if (balance.type === User_1.BalanceType.supply) {
+            supplyBalance += (balance.amount * prices.get(assetID)) / 10n ** assetConfig.decimals;
+        }
+        if (balance.type === User_1.BalanceType.borrow) {
+            borrowBalance += (balance.amount * prices.get(assetID)) / 10n ** assetConfig.decimals;
+        }
+    }
+    const availableToBorrow = (0, math_1.getAvailableToBorrow)(assetsConfig, assetsData, userLiteData.principals, prices);
+    for (const [_, assetID] of Object.entries(constants_1.ASSET_ID)) {
+        const assetConfig = assetsConfig.get(assetID);
+        const assetData = assetsData.get(assetID);
+        const balance = userLiteData.balances.get(assetID);
+        if (balance.type === User_1.BalanceType.supply) {
+            withdrawalLimits.set(assetID, (0, math_1.bigIntMax)((0, math_1.bigIntMin)(assetData.balance, ((supplyBalance -
+                (borrowBalance * constants_1.MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE) / assetConfig.collateralFactor) *
+                10n ** assetConfig.decimals) /
+                prices.get(assetID) -
+                5n, balance.amount), 0n));
+        }
+        else {
+            borrowLimits.set(assetID, (0, math_1.bigIntMin)((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(assetID), assetData.balance));
+        }
+    }
+    const limitUsed = borrowBalance + availableToBorrow;
+    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);
+    const healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
+    return {
+        ...userLiteData,
+        withdrawalLimits: withdrawalLimits,
+        borrowLimits: borrowLimits,
+        supplyBalance: supplyBalance,
+        borrowBalance: borrowBalance,
+        availableToBorrow: availableToBorrow,
+        limitUsedPercent: limitUsedPercent,
+        limitUsed: limitUsed,
+        liquidationData: liquidationData,
+        healthFactor: healthFactor,
+    };
+}
+exports.parseUserData = parseUserData;

package/dist/api/prices.d.ts

@@ -0,0 +1,9 @@
+import { PriceData } from '../types/Common';
+type SerializedPrice = {
+    symbol: string;
+    value: number;
+    timestamp: number;
+};
+export declare function getLiteDataBytesString(priceData: SerializedPrice): string;
+export declare function getPrices(): Promise<PriceData | undefined>;
+export {};

package/dist/api/prices.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrices = exports.getLiteDataBytesString = void 0;
+const core_1 = require("@ton/core");
+const ethers_1 = require("ethers");
+const constants_1 = require("../constants");
+function hexToArrayBuffer(input) {
+    if (typeof input !== 'string') {
+        throw new TypeError('Expected input to be a string');
+    }
+    if (input.length % 2 !== 0) {
+        throw new RangeError('Expected string to be an even number of characters');
+    }
+    if (input.startsWith('0x')) {
+        input = input.slice(2);
+    }
+    const view = new Uint8Array(input.length / 2);
+    for (let i = 0; i < input.length; i += 2) {
+        view[i / 2] = parseInt(input.substring(i, i + 2), 16);
+    }
+    return Buffer.from(view.buffer);
+}
+function convertStringToBytes32String(str) {
+    if (str.length > 31) {
+        const bytes32StringLength = 32 * 2 + 2; // 32 bytes (each byte uses 2 symbols) + 0x
+        if (str.length === bytes32StringLength && str.startsWith('0x')) {
+            return str;
+        }
+        else {
+            return ethers_1.ethers.utils.id(str);
+        }
+    }
+    else {
+        return ethers_1.ethers.utils.formatBytes32String(str);
+    }
+}
+function getLiteDataBytesString(priceData) {
+    let data = priceData.symbol.substr(2) + priceData.value.toString(16).padStart(64, '0');
+    data += Math.ceil(priceData.timestamp / 1000)
+        .toString(16)
+        .padStart(64, '0');
+    return data;
+}
+exports.getLiteDataBytesString = getLiteDataBytesString;
+async function getPrice(symbol) {
+    const res = await fetch(`https://api.redstone.finance/prices?symbol=${symbol}&provider=redstone&limit=1`);
+    const data = (await res.json());
+    const price = data[0];
+    const message = {
+        symbol: convertStringToBytes32String(price.symbol),
+        value: Math.round(price.value * 10 ** 8),
+        timestamp: price.timestamp,
+    };
+    let dictKey;
+    const dictValue = BigInt(message.value) * 10n;
+    switch (message.symbol) {
+        case '0x544f4e0000000000000000000000000000000000000000000000000000000000':
+            dictKey = constants_1.ASSET_ID.TON;
+            break;
+        case '0x5553445400000000000000000000000000000000000000000000000000000000':
+            dictKey = constants_1.ASSET_ID.jUSDT;
+            break;
+        case '0x5553444300000000000000000000000000000000000000000000000000000000':
+            dictKey = constants_1.ASSET_ID.jUSDC;
+            break;
+        default:
+            throw new Error('Unknown symbol');
+    }
+    const signature = hexToArrayBuffer(price.liteEvmSignature);
+    return {
+        data: Buffer.from(getLiteDataBytesString(message), 'hex'),
+        signature: signature,
+        dictKey: dictKey,
+        dictValue: dictValue,
+    };
+}
+async function getPrices() {
+    try {
+        const symbols = ['TON', 'USDT', 'USDC'];
+        const rawPriceData = [];
+        const priceDict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.BigUint(64));
+        const pricePromises = symbols.map(async (symbol) => {
+            const price = await getPrice(symbol);
+            priceDict.set(price.dictKey, price.dictValue);
+            rawPriceData.push(price);
+        });
+        await Promise.all(pricePromises);
+        const rawPricesDict = core_1.Dictionary.empty();
+        for (const data of rawPriceData) {
+            rawPricesDict.set(data.signature, (0, core_1.beginCell)().storeBuffer(data.data).endCell());
+        }
+        return {
+            dict: priceDict,
+            dataCell: (0, core_1.beginCell)()
+                .storeDictDirect(rawPricesDict, core_1.Dictionary.Keys.Buffer(65), core_1.Dictionary.Values.Cell())
+                .endCell(),
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return undefined;
+    }
+}
+exports.getPrices = getPrices;

package/dist/constants.d.ts

@@ -0,0 +1,38 @@
+import { Address, Cell } from '@ton/core';
+export declare const EVAA_MASTER_MAINNET: Address;
+export declare const MAINNET_VERSION = 2;
+export declare const EVAA_MASTER_TESTNET: Address;
+export declare const TESTNET_VERSION = 1;
+export declare const ASSET_ID: {
+    TON: bigint;
+    jUSDT: bigint;
+    jUSDC: bigint;
+};
+export declare const JETTON_MASTER_ADDRESSES: {
+    jUSDT_MAINNET: Address;
+    jUSDT_TESTNET: Address;
+    jUSDC_MAINNET: Address;
+    jUSDC_TESTNET: Address;
+};
+export declare const MASTER_CONSTANTS: {
+    FACTOR_SCALE: bigint;
+    ASSET_COEFFICIENT_SCALE: bigint;
+    ASSET_PRICE_SCALE: bigint;
+};
+export declare const LENDING_CODE: Cell;
+export declare const JETTON_WALLET_CODE: Cell;
+export declare const OPCODES: {
+    SUPPLY: number;
+    WITHDRAW: number;
+    LIQUIDATE: number;
+    JETTON_TRANSFER: number;
+};
+export declare const FEES: {
+    SUPPLY: bigint;
+    WITHDRAW: bigint;
+    SUPPLY_JETTON: bigint;
+    SUPPLY_JETTON_FWD: bigint;
+    LIQUIDATION: bigint;
+    LIQUIDATION_JETTON: bigint;
+    LIQUIDATION_JETTON_FWD: bigint;
+};