@evaafi/sdk 0.6.0-a → 0.6.1-a

package/dist/api/liquidation.d.ts

@@ -0,0 +1,136 @@
+import { Dictionary } from '@ton/core';
+import { AssetConfig, AssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, PoolAssetConfig, PoolConfig } from '../types/Master';
+import { UserBalance } from '../types/User';
+export declare function findAssetById(assetId: bigint, poolConfig: PoolConfig): PoolAssetConfig | undefined;
+export type AssetsValues = {
+    loanAssets: Dictionary<bigint, bigint>;
+    collateralAssets: Dictionary<bigint, bigint>;
+};
+export type SelectedAssets = {
+    selectedLoanId: bigint;
+    selectedCollateralId: bigint;
+    selectedLoanValue?: bigint;
+    selectedCollateralValue?: bigint;
+};
+export declare function calculateAssetsValues(principalsDict: Dictionary<bigint, bigint>, pricesDict: Dictionary<bigint, bigint>, assetsConfigDict: ExtendedAssetsConfig, assetsDataDict: ExtendedAssetsData, poolConfig: PoolConfig): AssetsValues;
+export declare function selectGreatestAssets(principalsDict: Dictionary<bigint, bigint>, pricesDict: Dictionary<bigint, bigint>, assetsConfigDict: ExtendedAssetsConfig, assetsDataDict: ExtendedAssetsData, poolConfig: PoolConfig): SelectedAssets;
+/**
+ * This function shows how to calculate min collateral amount value.
+ * when liquidator has not enough of loan asset to cover the full loan.
+ * @param transferredAmount amount of loan asset liquidator want to transfer.
+ * @param maxLiquidationAmount max liquidation amount value calculated.
+ * @param maxCollateralReward max collateral reward amount calculated.
+ * @returns minCollateralAmount value for safe liquidation.
+ */
+export declare function calculateMinCollateralByTransferredAmount(transferredAmount: bigint, maxLiquidationAmount: bigint, maxCollateralReward: bigint): bigint;
+/**
+ * Calculates liquidation amount and corresponding collateral amount
+ * @param supplyAmount user total supply worth amount
+ * @param borrowAmount user total borrow worth amount
+ * @param masterConstants evaa master contract constants
+ * @param loanAsset loan asset pool config
+ * @param collateralAsset collateral asset pool config
+ * @param principalsDict user principals
+ * @param assetsDataDict assets data collection
+ * @param assetsConfigDict assets config collection
+ * @param pricesDict assets prices
+ * @returns maxLiquidationAmount max loan asset amount to transfer
+ * @returns maxCollateralRewardAmount max collateral reward amount, which can be obtained
+ */
+export declare function calculateLiquidationAmounts(loanAsset: PoolAssetConfig, collateralAsset: PoolAssetConfig, supplyAmount: bigint, borrowAmount: bigint, // from calculate health params
+principalsDict: Dictionary<bigint, bigint>, pricesDict: Dictionary<bigint, bigint>, assetsDataDict: ExtendedAssetsData, assetsConfigDict: ExtendedAssetsConfig, masterConstants: MasterConstants): {
+    maxLiquidationAmount: bigint;
+    maxCollateralRewardAmount: bigint;
+};
+/**
+ * Check if the user is subject to liquidation
+ * @param args
+ */
+export declare function isLiquidatable(args: {
+    assetsData: ExtendedAssetsData;
+    assetsConfig: ExtendedAssetsConfig;
+    principals: Dictionary<bigint, bigint>;
+    prices: Dictionary<bigint, bigint>;
+    poolConfig: PoolConfig;
+}): boolean;
+/**
+ * Determines if the provided pair of assets forms a bad debt.
+ * @param totalSupply total supply worth amount
+ * @param totalBorrow total borrow worth amount
+ * @param liquidationBonus collateral liquidation bonus value
+ * @param masterConstants pool constants
+ */
+export declare function isBadDebt(totalSupply: bigint, totalBorrow: bigint, liquidationBonus: bigint, masterConstants: MasterConstants): boolean;
+/**
+ * Adds reserve to liquidation amount
+ * @param amount raw liquidation amount
+ * @param reserveFactor asset reserve factor
+ * @param factorScale asset reserve factor scale
+ * @returns liquidation amount with reserve
+ */
+export declare function addReserve(amount: bigint, reserveFactor: bigint, factorScale: bigint): bigint;
+/**
+ * Deducts reserve from liquidation amount
+ * @param amount liquidation amount with reserve
+ * @param reserveFactor asset reserve factor
+ * @param reserveFactorScale asset reserve factor scale
+ * @returns liquidation amount without reserve
+ */
+export declare function deductReserve(amount: bigint, reserveFactor: bigint, reserveFactorScale: bigint): bigint;
+/**
+ * Converts worth value to specified asset amount
+ * @param worth worth value (decimals = 9)
+ * @param scale asset scale (10^asset_decimals)
+ * @param price asset price
+ */
+export declare function toAssetAmount(worth: bigint, scale: bigint, price: bigint): bigint;
+/**
+ * Converts calculates worth value of specified asset amount
+ * @param amount worth value (decimals = 9)
+ * @param scale asset scale (10^asset_decimals)
+ * @param price asset price
+ */
+export declare function toAssetWorth(amount: bigint, scale: bigint, price: bigint): bigint;
+/**
+ * Adds liquidation bonus to reward value.
+ * @param value reward asset value
+ * @param bonus liquidation bonus factor
+ * @param scale liquidation bonus scale
+ */
+export declare function addLiquidationBonus(value: bigint, bonus: bigint, scale: bigint): bigint;
+/**
+ * Deducts liquidation bonus from reward value.
+ * @param value reward asset value
+ * @param bonus liquidation bonus factor
+ * @param scale liquidation bonus scale
+ */
+export declare function deductLiquidationBonus(value: bigint, bonus: bigint, scale: bigint): bigint;
+export type SuccessType = {
+    ok: true;
+};
+export type FailType = {
+    ok: false;
+};
+export type PreparedAssetInfo = {
+    config: AssetConfig;
+    data: AssetData;
+    price: bigint;
+    principal: bigint;
+    scale: bigint;
+    liquidationReserveFactor: bigint;
+    liquidationBonus: bigint;
+    present: UserBalance;
+    balance: bigint;
+    dust: bigint;
+};
+export type PreparedAssetInfoResult = (PreparedAssetInfo & SuccessType) | FailType;
+/**
+ * Prepares extended asset info
+ * @param assetId
+ * @param assetsConfigDict
+ * @param assetsDataDict
+ * @param pricesDict
+ * @param principalsDict
+ * @param masterConstants
+ */
+export declare function prepareAssetInfo(assetId: bigint, assetsConfigDict: ExtendedAssetsConfig, assetsDataDict: ExtendedAssetsData, pricesDict: Dictionary<bigint, bigint>, principalsDict: Dictionary<bigint, bigint>, masterConstants: MasterConstants): PreparedAssetInfoResult;

package/dist/api/liquidation.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareAssetInfo = exports.deductLiquidationBonus = exports.addLiquidationBonus = exports.toAssetWorth = exports.toAssetAmount = exports.deductReserve = exports.addReserve = exports.isBadDebt = exports.isLiquidatable = exports.calculateLiquidationAmounts = exports.calculateMinCollateralByTransferredAmount = exports.selectGreatestAssets = exports.calculateAssetsValues = exports.findAssetById = void 0;
+const core_1 = require("@ton/core");
+const math_1 = require("./math");
+const User_1 = require("../types/User");
+function findAssetById(assetId, poolConfig) {
+    return poolConfig.poolAssetsConfig.find(asset => asset.assetId === assetId);
+}
+exports.findAssetById = findAssetById;
+function calculateAssetsValues(principalsDict, pricesDict, assetsConfigDict, assetsDataDict, poolConfig) {
+    const loanAssets = core_1.Dictionary.empty();
+    const collateralAssets = core_1.Dictionary.empty();
+    for (const asset of poolConfig.poolAssetsConfig) {
+        const assetId = asset.assetId;
+        if (!principalsDict.has(assetId)) {
+            continue;
+        }
+        const assetPrincipal = principalsDict.get(assetId);
+        if (!pricesDict.has(assetId)) {
+            console.warn(`No price for asset ${asset.name}`);
+            continue;
+        }
+        const assetPrice = pricesDict.get(assetId);
+        if (!assetsDataDict.has(assetId)) {
+            console.warn(`Dynamics for assetId ${assetId} is not defined, skipping`);
+            continue;
+        }
+        const assetData = assetsDataDict.get(assetId);
+        if (!assetsConfigDict.has(assetId)) {
+            console.warn(`Config for assetId ${assetId} is not defined, skipping`);
+            continue;
+        }
+        const assetConfig = assetsConfigDict.get(assetId);
+        const assetScale = 10n ** assetConfig.decimals;
+        const { sRate, bRate } = assetData;
+        const assetPresent = (0, math_1.presentValue)(sRate, bRate, assetPrincipal, poolConfig.masterConstants);
+        const assetValue = assetPresent.amount * assetPrice / assetScale;
+        if (assetPresent.type === User_1.BalanceType.borrow) {
+            loanAssets.set(assetId, assetValue);
+        }
+        else {
+            collateralAssets.set(assetId, assetValue);
+        }
+    }
+    return { loanAssets, collateralAssets };
+}
+exports.calculateAssetsValues = calculateAssetsValues;
+function selectGreatestAssets(principalsDict, pricesDict, assetsConfigDict, assetsDataDict, poolConfig) {
+    let maxLoanId = 0n;
+    let maxLoanValue = 0n;
+    let maxCollateralId = 0n;
+    let maxCollateralValue = 0n;
+    const assetsValues = calculateAssetsValues(principalsDict, pricesDict, assetsConfigDict, assetsDataDict, poolConfig);
+    for (const [loanId, loanValue] of assetsValues.loanAssets) {
+        if (loanValue > maxLoanValue) {
+            maxLoanId = loanId;
+            maxLoanValue = loanValue;
+        }
+    }
+    for (const [collateralId, collateralValue] of assetsValues.collateralAssets) {
+        if (collateralValue > maxCollateralValue) {
+            maxCollateralValue = collateralValue;
+            maxCollateralId = collateralId;
+        }
+    }
+    return {
+        selectedLoanId: maxLoanId,
+        selectedLoanValue: maxLoanValue,
+        selectedCollateralId: maxCollateralId,
+        selectedCollateralValue: maxCollateralValue
+    };
+}
+exports.selectGreatestAssets = selectGreatestAssets;
+/**
+ * This function shows how to calculate min collateral amount value.
+ * when liquidator has not enough of loan asset to cover the full loan.
+ * @param transferredAmount amount of loan asset liquidator want to transfer.
+ * @param maxLiquidationAmount max liquidation amount value calculated.
+ * @param maxCollateralReward max collateral reward amount calculated.
+ * @returns minCollateralAmount value for safe liquidation.
+ */
+function calculateMinCollateralByTransferredAmount(transferredAmount, maxLiquidationAmount, maxCollateralReward) {
+    if (maxLiquidationAmount === 0n) {
+        return 0n;
+    }
+    return maxCollateralReward * transferredAmount / maxLiquidationAmount;
+}
+exports.calculateMinCollateralByTransferredAmount = calculateMinCollateralByTransferredAmount;
+/**
+ * Calculates liquidation amount and corresponding collateral amount
+ * @param supplyAmount user total supply worth amount
+ * @param borrowAmount user total borrow worth amount
+ * @param masterConstants evaa master contract constants
+ * @param loanAsset loan asset pool config
+ * @param collateralAsset collateral asset pool config
+ * @param principalsDict user principals
+ * @param assetsDataDict assets data collection
+ * @param assetsConfigDict assets config collection
+ * @param pricesDict assets prices
+ * @returns maxLiquidationAmount max loan asset amount to transfer
+ * @returns maxCollateralRewardAmount max collateral reward amount, which can be obtained
+ */
+function calculateLiquidationAmounts(loanAsset, collateralAsset, supplyAmount, borrowAmount, // from calculate health params
+principalsDict, pricesDict, assetsDataDict, assetsConfigDict, masterConstants) {
+    const loanInfo = prepareAssetInfo(loanAsset.assetId, assetsConfigDict, assetsDataDict, pricesDict, principalsDict, masterConstants);
+    const collateralInfo = prepareAssetInfo(collateralAsset.assetId, assetsConfigDict, assetsDataDict, pricesDict, principalsDict, masterConstants);
+    if (!loanInfo.ok || !collateralInfo.ok ||
+        loanInfo.present.type !== User_1.BalanceType.borrow ||
+        collateralInfo.present.type !== User_1.BalanceType.supply) {
+        return { maxLiquidationAmount: 0n, maxCollateralRewardAmount: 0n };
+    }
+    const liquidationBonusScale = masterConstants.ASSET_LIQUIDATION_BONUS_SCALE;
+    const collateralThreshold = masterConstants.COLLATERAL_WORTH_THRESHOLD; // basically 100$ worth (100*10^9)
+    const reserveFactorScale = masterConstants.ASSET_RESERVE_FACTOR_SCALE;
+    const reserveFactor = loanInfo.liquidationReserveFactor;
+    const liquidationBonus = collateralInfo.liquidationBonus;
+    let allowedCollateralValue = toAssetWorth(collateralInfo.balance, collateralInfo.scale, collateralInfo.price);
+    const _isBadDebt = isBadDebt(supplyAmount, borrowAmount, liquidationBonus, masterConstants);
+    if (!_isBadDebt) {
+        allowedCollateralValue = math_1.BigMath.min(allowedCollateralValue, math_1.BigMath.max(allowedCollateralValue / 2n, collateralThreshold));
+    }
+    const loanValue = toAssetWorth(loanInfo.balance, loanInfo.scale, loanInfo.price);
+    const baseLiquidationValue = math_1.BigMath.min(
+    // deductReserve(loanValue, reserveFactor, reserveFactorScale),
+    loanValue, deductLiquidationBonus(allowedCollateralValue, liquidationBonus, liquidationBonusScale));
+    // calculate collateral amount
+    let collateralAmount = addLiquidationBonus(baseLiquidationValue, liquidationBonus, liquidationBonusScale);
+    collateralAmount = toAssetAmount(collateralAmount, collateralInfo.scale, collateralInfo.price);
+    // calculate loan amount
+    let liquidationAmount = addReserve(baseLiquidationValue, reserveFactor, reserveFactorScale);
+    liquidationAmount = toAssetAmount(liquidationAmount, loanInfo.scale, loanInfo.price);
+    return {
+        maxLiquidationAmount: liquidationAmount,
+        maxCollateralRewardAmount: collateralAmount
+    };
+}
+exports.calculateLiquidationAmounts = calculateLiquidationAmounts;
+/**
+ * Check if the user is subject to liquidation
+ * @param args
+ */
+function isLiquidatable(args) {
+    const { isLiquidatable: res } = (0, math_1.calculateHealthParams)(args);
+    return res;
+}
+exports.isLiquidatable = isLiquidatable;
+/**
+ * Determines if the provided pair of assets forms a bad debt.
+ * @param totalSupply total supply worth amount
+ * @param totalBorrow total borrow worth amount
+ * @param liquidationBonus collateral liquidation bonus value
+ * @param masterConstants pool constants
+ */
+function isBadDebt(totalSupply, totalBorrow, liquidationBonus, masterConstants) {
+    return totalSupply * masterConstants.ASSET_LIQUIDATION_BONUS_SCALE < totalBorrow * liquidationBonus;
+}
+exports.isBadDebt = isBadDebt;
+/**
+ * Adds reserve to liquidation amount
+ * @param amount raw liquidation amount
+ * @param reserveFactor asset reserve factor
+ * @param factorScale asset reserve factor scale
+ * @returns liquidation amount with reserve
+ */
+function addReserve(amount, reserveFactor, factorScale) {
+    return amount * factorScale / (factorScale - reserveFactor);
+}
+exports.addReserve = addReserve;
+/**
+ * Deducts reserve from liquidation amount
+ * @param amount liquidation amount with reserve
+ * @param reserveFactor asset reserve factor
+ * @param reserveFactorScale asset reserve factor scale
+ * @returns liquidation amount without reserve
+ */
+function deductReserve(amount, reserveFactor, reserveFactorScale) {
+    return amount * (reserveFactorScale - reserveFactor) / reserveFactorScale;
+}
+exports.deductReserve = deductReserve;
+/**
+ * Converts worth value to specified asset amount
+ * @param worth worth value (decimals = 9)
+ * @param scale asset scale (10^asset_decimals)
+ * @param price asset price
+ */
+function toAssetAmount(worth, scale, price) {
+    return worth * scale / price;
+}
+exports.toAssetAmount = toAssetAmount;
+/**
+ * Converts calculates worth value of specified asset amount
+ * @param amount worth value (decimals = 9)
+ * @param scale asset scale (10^asset_decimals)
+ * @param price asset price
+ */
+function toAssetWorth(amount, scale, price) {
+    return amount * price / scale;
+}
+exports.toAssetWorth = toAssetWorth;
+/**
+ * Adds liquidation bonus to reward value.
+ * @param value reward asset value
+ * @param bonus liquidation bonus factor
+ * @param scale liquidation bonus scale
+ */
+function addLiquidationBonus(value, bonus, scale) {
+    return value * bonus / scale;
+}
+exports.addLiquidationBonus = addLiquidationBonus;
+/**
+ * Deducts liquidation bonus from reward value.
+ * @param value reward asset value
+ * @param bonus liquidation bonus factor
+ * @param scale liquidation bonus scale
+ */
+function deductLiquidationBonus(value, bonus, scale) {
+    return value * scale / bonus;
+}
+exports.deductLiquidationBonus = deductLiquidationBonus;
+/**
+ * Prepares extended asset info
+ * @param assetId
+ * @param assetsConfigDict
+ * @param assetsDataDict
+ * @param pricesDict
+ * @param principalsDict
+ * @param masterConstants
+ */
+function prepareAssetInfo(assetId, assetsConfigDict, assetsDataDict, pricesDict, principalsDict, masterConstants) {
+    if (!assetsConfigDict.has(assetId) ||
+        !assetsDataDict.has(assetId) ||
+        !pricesDict.has(assetId) ||
+        !principalsDict.has(assetId)) {
+        return { ok: false };
+    }
+    const config = assetsConfigDict.get(assetId);
+    const data = assetsDataDict.get(assetId);
+    const base = {
+        ok: true,
+        config, data,
+        price: pricesDict.get(assetId),
+        principal: principalsDict.get(assetId),
+        scale: 10n ** config.decimals,
+        liquidationReserveFactor: config.liquidationReserveFactor,
+        liquidationBonus: config.liquidationBonus
+    };
+    const assetPresent = (0, math_1.presentValue)(data.sRate, data.bRate, base.principal, masterConstants);
+    const dustPresent = (0, math_1.presentValue)(data.sRate, data.bRate, config.dust, masterConstants);
+    return { ...base, present: assetPresent, balance: assetPresent.amount, dust: dustPresent.amount };
+}
+exports.prepareAssetInfo = prepareAssetInfo;

package/dist/api/math.d.ts

@@ -1,11 +1,20 @@
 import { AgregatedBalances, AssetConfig, AssetData, AssetInterest, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, PoolConfig } from '../types/Master';
 import { Dictionary } from '@ton/core';
-import { LiquidationData, PredictHealthFactorArgs, UserBalance } from '../types/User';
+import { HealthParamsArgs, LiquidationData, PredictHealthFactorArgs, UserBalance } from '../types/User';
 export declare function mulFactor(decimal: bigint, a: bigint, b: bigint): bigint;
 export declare function mulDiv(x: bigint, y: bigint, z: bigint): bigint;
 export declare function mulDivC(x: bigint, y: bigint, z: bigint): bigint;
+export declare function bigAbs(value: bigint): bigint;
 export declare function bigIntMax(...args: bigint[]): bigint;
 export declare function bigIntMin(...args: bigint[]): bigint;
+export declare const BigMath: {
+    mulFactor: typeof mulFactor;
+    mulDiv: typeof mulDiv;
+    mulDivC: typeof mulDivC;
+    abs: typeof bigAbs;
+    min: typeof bigIntMin;
+    max: typeof bigIntMax;
+};
 export declare function calculatePresentValue(index: bigint, principalValue: bigint, masterConstants: MasterConstants): bigint;
 export declare function calculateCurrentRates(assetConfig: AssetConfig, assetData: AssetData, masterConstants: MasterConstants): {
     sRate: bigint;
@@ -20,14 +29,32 @@ export declare function checkNotInDebtAtAll(principals: Dictionary<bigint, bigin
 export declare function getAgregatedBalances(assetsData: ExtendedAssetsData, assetsConfig: ExtendedAssetsConfig, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants): AgregatedBalances;
 export declare function calculateMaximumWithdrawAmount(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants, assetId: bigint): bigint;
 export declare function getAvailableToBorrow(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, masterConstants: MasterConstants): bigint;
+/**
+ * Calculates balance value for asset principal.
+ * @param sRate asset supply rate
+ * @param bRate asset borrow rate
+ * @param principalValue asset principal value
+ * @param masterConstants pool constants
+ */
 export declare function presentValue(sRate: bigint, bRate: bigint, principalValue: bigint, masterConstants: MasterConstants): UserBalance;
 /**
- *
- * @param assetsConfig
- * @param assetsData
- * @param principals
- * @param prices
- * @param poolConfig
+ * Calculates health parameters of the specified user account based on its parameters
+ * @param parameters
+ */
+export declare function calculateHealthParams(parameters: HealthParamsArgs): {
+    totalDebt: bigint;
+    totalLimit: bigint;
+    totalSupply: bigint;
+    isLiquidatable: boolean;
+    isBadDebt: (liquidationBonus: bigint) => boolean;
+};
+/**
+ * Calculates liquidation data for greatest loan and collateral assets
+ * @param assetsConfig assets config dictionary
+ * @param assetsData assets data dictionary
+ * @param principals principals dictionary
+ * @param prices prices dictionary
+ * @param poolConfig pool config
  * @returns can return UNDEFINED_ASSET if there are no assets
  */
 export declare function calculateLiquidationData(assetsConfig: ExtendedAssetsConfig, assetsData: ExtendedAssetsData, principals: Dictionary<bigint, bigint>, prices: Dictionary<bigint, bigint>, poolConfig: PoolConfig): LiquidationData;