@gearbox-protocol/sdk 1.4.0 → 1.5.0

package/lib/apy/index.d.ts

@@ -1,5 +1,6 @@
 import { LPTokens, SupportedToken } from "../tokens/token";
 export declare type TokensWithAPY = LPTokens | Extract<SupportedToken, "LDO">;
+export declare type LpTokensAPY = Record<TokensWithAPY, number>;
 export * from "./convexAPY";
 export * from "./curveAPY";
 export * from "./lidoAPY";

package/lib/core/adapter.d.ts

@@ -0,0 +1,34 @@
+import { Signer } from "ethers";
+import { AdapterInterface } from "../contracts/adapters";
+import { SupportedContract } from "../contracts/contracts";
+import { PathFinderResultStructOutput } from "../types/contracts/pathfinder/interfaces/IPathFinder";
+import { EVMTx } from "./eventOrTx";
+export declare enum AdapterType {
+    Swap = 1,
+    LP = 2
+}
+interface BaseAdapterProps {
+    name: string;
+    type: AdapterType;
+    adapterInterface: AdapterInterface;
+    contractAddress: string;
+    adapterAddress: string;
+    contractSymbol: SupportedContract;
+}
+interface ExecuteProps {
+    tradePath: PathFinderResultStructOutput;
+    slippage: number;
+    signer: Signer;
+}
+export declare class BaseAdapter {
+    readonly name: string;
+    readonly type: AdapterType;
+    readonly adapterInterface: AdapterInterface;
+    readonly contractAddress: string;
+    readonly adapterAddress: string;
+    readonly contractSymbol: SupportedContract;
+    constructor(props: BaseAdapterProps);
+    execute(props: ExecuteProps): Promise<EVMTx>;
+    static connect(tradePath: PathFinderResultStructOutput): BaseAdapter;
+}
+export {};

package/lib/core/adapter.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAdapter = exports.AdapterType = void 0;
+var adapters_1 = require("../contracts/adapters");
+var AdapterType;
+(function (AdapterType) {
+    AdapterType[AdapterType["Swap"] = 1] = "Swap";
+    AdapterType[AdapterType["LP"] = 2] = "LP";
+})(AdapterType = exports.AdapterType || (exports.AdapterType = {}));
+var BaseAdapter = /** @class */ (function () {
+    function BaseAdapter(props) {
+        this.name = props.name;
+        this.type = props.type;
+        this.adapterInterface = props.adapterInterface;
+        this.adapterAddress = props.adapterAddress;
+        this.contractAddress = props.contractAddress;
+        this.contractSymbol = props.contractSymbol;
+    }
+    BaseAdapter.prototype.execute = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                console.debug(props);
+                return [2 /*return*/, {}];
+            });
+        });
+    };
+    BaseAdapter.connect = function (tradePath) {
+        console.debug(tradePath);
+        return new BaseAdapter({
+            name: "",
+            type: AdapterType.Swap,
+            adapterInterface: adapters_1.AdapterInterface.NO_SWAP,
+            adapterAddress: "",
+            contractAddress: "",
+            contractSymbol: "CONVEX_3CRV_POOL",
+        });
+    };
+    return BaseAdapter;
+}());
+exports.BaseAdapter = BaseAdapter;

package/lib/core/assets.d.ts

@@ -0,0 +1,34 @@
+import { BigNumber } from "ethers";
+import { LPTokens } from "../tokens/token";
+import { TokenData } from "../tokens/tokenData";
+export interface Asset {
+    token: string;
+    balance: BigNumber;
+}
+export interface LpAsset extends Asset {
+    symbol: LPTokens;
+    name: string;
+}
+interface NextAssetProps<T extends Asset> {
+    allowedTokens: Array<string>;
+    selectedAssets: Array<T>;
+    balances: Record<string, BigNumber>;
+    tokensList: Record<string, TokenData>;
+    prices?: Record<string, BigNumber>;
+}
+export declare function nextAsset<T extends Asset>({ allowedTokens, selectedAssets, balances, tokensList, prices, }: NextAssetProps<T>): string | undefined;
+export declare function getBalances(allowedTokens: Array<string>, externalBalances: Record<string, BigNumber>): Record<string, BigNumber>;
+export declare function constructAssetRecord<A extends Asset>(a: Array<A>): Record<string, A>;
+export declare type WrapResult<T> = [Array<T>, BigNumber, BigNumber];
+export declare const memoWrapETH: (ethAddress: string, wethAddress: string) => <T extends Asset>(assets: T[]) => WrapResult<T>;
+/**
+ * Sums the the second assets list into the first assets list
+ * Creates new assets.
+ */
+export declare function sumAssets<A extends Asset, B extends Asset>(a: Array<A>, b: Array<B>): Array<A | B>;
+/**
+ * Subtracts the the second assets list from the first assets list
+ * Balance cant be negative; doesn't create new assets.
+ */
+export declare function subAssets<A extends Asset, B extends Asset>(a: Array<A>, b: Array<B>): Array<A>;
+export {};

package/lib/core/assets.js

@@ -0,0 +1,98 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subAssets = exports.sumAssets = exports.memoWrapETH = exports.constructAssetRecord = exports.getBalances = exports.nextAsset = void 0;
+var ethers_1 = require("ethers");
+var math_1 = require("../utils/math");
+var creditAccount_1 = require("./creditAccount");
+function nextAsset(_a) {
+    var allowedTokens = _a.allowedTokens, selectedAssets = _a.selectedAssets, balances = _a.balances, tokensList = _a.tokensList, _b = _a.prices, prices = _b === void 0 ? {} : _b;
+    var selectedRecord = selectedAssets.reduce(function (acc, _a) {
+        var token = _a.token;
+        acc[token.toLowerCase()] = true;
+        return acc;
+    }, {});
+    var notSelected = allowedTokens.filter(function (allowedToken) {
+        var alreadySelected = selectedRecord[allowedToken.toLowerCase()];
+        return !alreadySelected;
+    });
+    var sorted = (0, creditAccount_1.sortBalances)(getBalances(notSelected, balances), prices, tokensList);
+    var address = (sorted[0] || [])[0];
+    return address;
+}
+exports.nextAsset = nextAsset;
+function getBalances(allowedTokens, externalBalances) {
+    return allowedTokens.reduce(function (acc, address) {
+        var _a;
+        var addressLc = address.toLowerCase();
+        return __assign(__assign({}, acc), (_a = {}, _a[addressLc] = externalBalances[addressLc] || ethers_1.BigNumber.from(0), _a));
+    }, {});
+}
+exports.getBalances = getBalances;
+function constructAssetRecord(a) {
+    var record = a.reduce(function (acc, asset) {
+        acc[asset.token] = asset;
+        return acc;
+    }, {});
+    return record;
+}
+exports.constructAssetRecord = constructAssetRecord;
+var memoWrapETH = function (ethAddress, wethAddress) {
+    return function wrapETH(assets) {
+        var assetsRecord = constructAssetRecord(assets);
+        var weth = assetsRecord[wethAddress];
+        var _a = (weth || {}).balance, wethAmount = _a === void 0 ? ethers_1.BigNumber.from(0) : _a;
+        var eth = assetsRecord[ethAddress];
+        var _b = (eth || {}).balance, ethAmount = _b === void 0 ? ethers_1.BigNumber.from(0) : _b;
+        var wethOrETH = weth || eth;
+        if (wethOrETH) {
+            assetsRecord[wethAddress] = __assign(__assign({}, wethOrETH), { token: wethAddress, balance: (0, math_1.nonNegativeBn)(ethAmount).add((0, math_1.nonNegativeBn)(wethAmount)) });
+        }
+        if (eth) {
+            delete assetsRecord[ethAddress];
+        }
+        return [Object.values(assetsRecord), ethAmount, wethAmount];
+    };
+};
+exports.memoWrapETH = memoWrapETH;
+/**
+ * Sums the the second assets list into the first assets list
+ * Creates new assets.
+ */
+function sumAssets(a, b) {
+    var aRecord = constructAssetRecord(a);
+    var resRecord = b.reduce(function (acc, bAsset) {
+        var aAsset = acc[bAsset.token];
+        var _a = (aAsset || {}).balance, amount = _a === void 0 ? ethers_1.BigNumber.from(0) : _a;
+        var amountSum = (0, math_1.nonNegativeBn)(bAsset.balance).add((0, math_1.nonNegativeBn)(amount));
+        var aOrB = aAsset || bAsset;
+        acc[bAsset.token] = __assign(__assign({}, aOrB), { balance: amountSum });
+        return acc;
+    }, aRecord);
+    return Object.values(resRecord);
+}
+exports.sumAssets = sumAssets;
+/**
+ * Subtracts the the second assets list from the first assets list
+ * Balance cant be negative; doesn't create new assets.
+ */
+function subAssets(a, b) {
+    var bRecord = constructAssetRecord(b);
+    return a.map(function (asset) {
+        var bAsset = bRecord[asset.token];
+        var _a = (bAsset || {}).balance, bAmount = _a === void 0 ? ethers_1.BigNumber.from(0) : _a;
+        var amountSub = (0, math_1.nonNegativeBn)(asset.balance).sub((0, math_1.nonNegativeBn)(bAmount));
+        return __assign(__assign({}, asset), { balance: (0, math_1.nonNegativeBn)(amountSub) });
+    });
+}
+exports.subAssets = subAssets;

package/lib/core/creditAccount.d.ts

@@ -1,10 +1,8 @@
 import { BigNumber } from "ethers";
+import { LpTokensAPY } from "../apy";
 import { CreditAccountDataExtendedPayload, CreditAccountDataPayload } from "../payload/creditAccount";
 import { TokenData } from "../tokens/tokenData";
-export interface Balance {
-    address: string;
-    balance: BigNumber;
-}
+import { Asset, LpAsset } from "./assets";
 export declare class CreditAccountData {
     readonly id: string;
     readonly addr: string;
@@ -23,7 +21,7 @@ export declare class CreditAccountData {
     isDeleting: boolean;
     readonly version: number;
     constructor(payload: CreditAccountDataPayload);
-    balancesSorted(prices: Record<string, BigNumber>, tokens: Record<string, TokenData>): Array<Balance>;
+    balancesSorted(prices: Record<string, BigNumber>, tokens: Record<string, TokenData>): Array<Asset>;
 }
 export declare function sortBalances(balances: Record<string, BigNumber>, prices: Record<string, BigNumber>, tokens: Record<string, TokenData>): Array<[string, BigNumber]>;
 export declare function tokensAbcComparator(t1?: TokenData, t2?: TokenData): 1 | -1;
@@ -37,3 +35,14 @@ export declare class CreditAccountDataExtended extends CreditAccountData {
     readonly since: number;
     constructor(payload: CreditAccountDataExtendedPayload);
 }
+export interface CalcOverallAPYProps {
+    lpAssets: Array<LpAsset>;
+    lpAPY: LpTokensAPY | undefined;
+    prices: Record<string, BigNumber>;
+    tokensList: Record<string, TokenData>;
+    totalValue: BigNumber | undefined;
+    debt: BigNumber | undefined;
+    borrowRate: number;
+    underlyingToken: string;
+}
+export declare function calcOverallAPY({ lpAssets, lpAPY, prices, tokensList, totalValue, debt, borrowRate, underlyingToken, }: CalcOverallAPYProps): number | undefined;

package/lib/core/creditAccount.js

@@ -15,8 +15,9 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreditAccountDataExtended = exports.amountAbcComparator = exports.tokensAbcComparator = exports.sortBalances = exports.CreditAccountData = void 0;
+exports.calcOverallAPY = exports.CreditAccountDataExtended = exports.amountAbcComparator = exports.tokensAbcComparator = exports.sortBalances = exports.CreditAccountData = void 0;
 var ethers_1 = require("ethers");
+var formatter_1 = require("../utils/formatter");
 var price_1 = require("../utils/price");
 var constants_1 = require("./constants");
 var CreditAccountData = /** @class */ (function () {
@@ -57,8 +58,8 @@ var CreditAccountData = /** @class */ (function () {
     }
     CreditAccountData.prototype.balancesSorted = function (prices, tokens) {
         return sortBalances(this.balances, prices, tokens).map(function (_a) {
-            var address = _a[0], balance = _a[1];
-            return ({ address: address, balance: balance });
+            var token = _a[0], balance = _a[1];
+            return ({ token: token, balance: balance });
         });
     };
     return CreditAccountData;
@@ -113,3 +114,34 @@ var CreditAccountDataExtended = /** @class */ (function (_super) {
     return CreditAccountDataExtended;
 }(CreditAccountData));
 exports.CreditAccountDataExtended = CreditAccountDataExtended;
+function calcOverallAPY(_a) {
+    var lpAssets = _a.lpAssets, lpAPY = _a.lpAPY, prices = _a.prices, tokensList = _a.tokensList, totalValue = _a.totalValue, debt = _a.debt, borrowRate = _a.borrowRate, underlyingToken = _a.underlyingToken;
+    if (!lpAPY || !totalValue || !debt)
+        return undefined;
+    var assetAPYMoney = lpAssets.reduce(function (acc, _a) {
+        var symbol = _a.symbol, tokenAddress = _a.token, amount = _a.balance;
+        var apy = lpAPY[symbol] || 0;
+        var price = prices[tokenAddress] || ethers_1.BigNumber.from(0);
+        var token = tokensList[tokenAddress];
+        var apyBN = (0, formatter_1.toBN)((apy / constants_1.PERCENTAGE_DECIMALS).toString(), constants_1.WAD_DECIMALS_POW);
+        var money = (0, price_1.calcTotalPrice)(price, amount, token === null || token === void 0 ? void 0 : token.decimals);
+        var apyMoney = money.mul(apyBN).div(constants_1.WAD);
+        return acc.add(apyMoney);
+    }, ethers_1.BigNumber.from(0));
+    var _b = tokensList[underlyingToken] || {}, _c = _b.decimals, underlyingDecimals = _c === void 0 ? 18 : _c, _d = _b.address, underlyingAddress = _d === void 0 ? "" : _d;
+    var underlyingPrice = prices[underlyingAddress] || constants_1.PRICE_DECIMALS;
+    var assetAPYAmountInUnderlying = (0, price_1.convertByPrice)(assetAPYMoney, {
+        price: underlyingPrice,
+        decimals: underlyingDecimals,
+    });
+    var borrowAPY = (0, formatter_1.toBN)((borrowRate / constants_1.PERCENTAGE_DECIMALS).toString(), constants_1.WAD_DECIMALS_POW);
+    var debtAPY = debt.mul(borrowAPY).div(constants_1.WAD);
+    var yourAssets = totalValue.sub(debt);
+    var apyInPercent = assetAPYAmountInUnderlying
+        .sub(debtAPY)
+        .mul(constants_1.PERCENTAGE_DECIMALS)
+        .mul(constants_1.WAD)
+        .div(yourAssets);
+    return Number((0, formatter_1.toSignificant)(apyInPercent, constants_1.WAD_DECIMALS_POW));
+}
+exports.calcOverallAPY = calcOverallAPY;

package/lib/core/creditManager.d.ts

@@ -1,6 +1,8 @@
 import { BigNumber, ethers, Signer } from "ethers";
 import { CreditManagerDataPayload, CreditManagerStatPayload } from "../payload/creditManager";
+import { TokenData } from "../tokens/tokenData";
 import { ICreditManager } from "../types";
+import { Asset } from "./assets";
 import { MultiCall } from "./multicall";
 export declare class CreditManagerData {
     readonly id: string;
@@ -38,9 +40,6 @@ export declare class CreditManagerData {
     protected validateOpenAccountV1(collateral: BigNumber, debt: BigNumber): true;
     protected validateOpenAccountV2(debt: BigNumber): true;
 }
-export declare function calcMaxIncreaseBorrow(healthFactor: number, borrowAmountPlusInterest: BigNumber, maxLeverageFactor: number): BigNumber;
-export declare function calcHealthFactorAfterIncreasingBorrow(healthFactor: number | undefined, borrowAmountPlusInterest: BigNumber | undefined, additional: BigNumber): number;
-export declare function calcHealthFactorAfterAddingCollateral(healthFactor: number | undefined, borrowAmountPlusInterest: BigNumber | undefined, additionalCollateral: BigNumber): number;
 export declare class CreditManagerStat extends CreditManagerData {
     readonly uniqueUsers: number;
     readonly openedAccountsCount: number;
@@ -55,3 +54,13 @@ export declare class CreditManagerStat extends CreditManagerData {
     readonly totalLosses: BigNumber;
     constructor(payload: CreditManagerStatPayload);
 }
+export declare function calcMaxIncreaseBorrow(healthFactor: number, borrowAmountPlusInterest: BigNumber, maxLeverageFactor: number): BigNumber;
+export interface CalcHealthFactorProps {
+    assets: Array<Asset>;
+    prices: Record<string, BigNumber>;
+    tokensList: Record<string, TokenData>;
+    liquidationThresholds: Record<string, BigNumber>;
+    underlyingToken: TokenData | undefined;
+    borrowed: BigNumber;
+}
+export declare function calcHealthFactor({ assets, prices, tokensList, liquidationThresholds, underlyingToken, borrowed, }: CalcHealthFactorProps): number;

package/lib/core/creditManager.js

@@ -26,9 +26,10 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreditManagerStat = exports.calcHealthFactorAfterAddingCollateral = exports.calcHealthFactorAfterIncreasingBorrow = exports.calcMaxIncreaseBorrow = exports.CreditManagerData = void 0;
+exports.calcHealthFactor = exports.calcMaxIncreaseBorrow = exports.CreditManagerStat = exports.CreditManagerData = void 0;
 var ethers_1 = require("ethers");
 var types_1 = require("../types");
+var price_1 = require("../utils/price");
 var constants_1 = require("./constants");
 var errors_1 = require("./errors");
 var CreditManagerData = /** @class */ (function () {
@@ -136,41 +137,6 @@ var CreditManagerData = /** @class */ (function () {
     return CreditManagerData;
 }());
 exports.CreditManagerData = CreditManagerData;
-function calcMaxIncreaseBorrow(healthFactor, borrowAmountPlusInterest, maxLeverageFactor) {
-    var healthFactorPercentage = Math.floor(healthFactor * constants_1.PERCENTAGE_FACTOR);
-    var minHealthFactor = maxLeverageFactor > 0
-        ? Math.floor((constants_1.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD *
-            (maxLeverageFactor + constants_1.LEVERAGE_DECIMALS)) /
-            maxLeverageFactor)
-        : 10000;
-    var result = borrowAmountPlusInterest
-        .mul(healthFactorPercentage - minHealthFactor)
-        .div(minHealthFactor - constants_1.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD);
-    return result.isNegative() ? ethers_1.BigNumber.from(0) : result;
-}
-exports.calcMaxIncreaseBorrow = calcMaxIncreaseBorrow;
-function calcHealthFactorAfterIncreasingBorrow(healthFactor, borrowAmountPlusInterest, additional) {
-    if (!healthFactor || !borrowAmountPlusInterest)
-        return 0;
-    var healthFactorPercentage = Math.floor(healthFactor * constants_1.PERCENTAGE_FACTOR);
-    return (borrowAmountPlusInterest
-        .mul(healthFactorPercentage)
-        .add(additional.mul(constants_1.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD))
-        .div(borrowAmountPlusInterest.add(additional))
-        .toNumber() / constants_1.PERCENTAGE_FACTOR);
-}
-exports.calcHealthFactorAfterIncreasingBorrow = calcHealthFactorAfterIncreasingBorrow;
-function calcHealthFactorAfterAddingCollateral(healthFactor, borrowAmountPlusInterest, additionalCollateral) {
-    if (!healthFactor || !borrowAmountPlusInterest)
-        return 0;
-    var healthFactorPercentage = Math.floor(healthFactor * constants_1.PERCENTAGE_FACTOR);
-    return (borrowAmountPlusInterest
-        .mul(healthFactorPercentage)
-        .add(additionalCollateral.mul(constants_1.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD))
-        .div(borrowAmountPlusInterest)
-        .toNumber() / constants_1.PERCENTAGE_FACTOR);
-}
-exports.calcHealthFactorAfterAddingCollateral = calcHealthFactorAfterAddingCollateral;
 var CreditManagerStat = /** @class */ (function (_super) {
     __extends(CreditManagerStat, _super);
     function CreditManagerStat(payload) {
@@ -191,3 +157,35 @@ var CreditManagerStat = /** @class */ (function (_super) {
     return CreditManagerStat;
 }(CreditManagerData));
 exports.CreditManagerStat = CreditManagerStat;
+function calcMaxIncreaseBorrow(healthFactor, borrowAmountPlusInterest, maxLeverageFactor) {
+    var healthFactorPercentage = Math.floor(healthFactor * constants_1.PERCENTAGE_FACTOR);
+    var minHealthFactor = maxLeverageFactor > 0
+        ? Math.floor((constants_1.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD *
+            (maxLeverageFactor + constants_1.LEVERAGE_DECIMALS)) /
+            maxLeverageFactor)
+        : 10000;
+    var result = borrowAmountPlusInterest
+        .mul(healthFactorPercentage - minHealthFactor)
+        .div(minHealthFactor - constants_1.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD);
+    return result.isNegative() ? ethers_1.BigNumber.from(0) : result;
+}
+exports.calcMaxIncreaseBorrow = calcMaxIncreaseBorrow;
+function calcHealthFactor(_a) {
+    var assets = _a.assets, prices = _a.prices, tokensList = _a.tokensList, liquidationThresholds = _a.liquidationThresholds, underlyingToken = _a.underlyingToken, borrowed = _a.borrowed;
+    var assetLTMoney = assets.reduce(function (acc, _a) {
+        var tokenAddress = _a.token, amount = _a.balance;
+        var lt = liquidationThresholds[tokenAddress] || ethers_1.BigNumber.from(0);
+        var price = prices[tokenAddress] || ethers_1.BigNumber.from(0);
+        var token = tokensList[tokenAddress];
+        var money = (0, price_1.calcTotalPrice)(price, amount, token === null || token === void 0 ? void 0 : token.decimals);
+        var ltMoney = money.mul(lt).div(constants_1.PERCENTAGE_FACTOR);
+        return acc.add(ltMoney);
+    }, ethers_1.BigNumber.from(0));
+    var underlyingPrice = prices[(underlyingToken === null || underlyingToken === void 0 ? void 0 : underlyingToken.address) || ""] || constants_1.PRICE_DECIMALS;
+    var borrowedMoney = (0, price_1.calcTotalPrice)(underlyingPrice, borrowed, underlyingToken === null || underlyingToken === void 0 ? void 0 : underlyingToken.decimals);
+    var hfInPercent = borrowedMoney.gt(0)
+        ? assetLTMoney.mul(constants_1.PERCENTAGE_FACTOR).div(borrowedMoney)
+        : ethers_1.BigNumber.from(0);
+    return hfInPercent.toNumber() / constants_1.PERCENTAGE_FACTOR;
+}
+exports.calcHealthFactor = calcHealthFactor;

package/lib/core/strategy.d.ts

@@ -1,5 +1,8 @@
 import { BigNumber } from "ethers";
 import { TokensWithAPY } from "../apy";
+import { TokenData } from "../tokens/tokenData";
+import { Asset } from "./assets";
+import { CreditManagerData } from "./creditManager";
 export interface StrategyPayload {
     apy?: number;
     apyTokenSymbol: TokensWithAPY;
@@ -14,10 +17,15 @@ interface PoolStats {
     borrowRate: number;
 }
 declare type PoolList = Record<string, PoolStats>;
-interface TokenDescription {
-    price: BigNumber;
-    amount: BigNumber;
-    decimals: number | undefined;
+interface LiquidationPriceProps {
+    assets: Array<Asset>;
+    prices: Record<string, BigNumber>;
+    tokensList: Record<string, TokenData>;
+    liquidationThresholds: Record<string, BigNumber>;
+    borrowed: BigNumber;
+    underlyingToken: TokenData;
+    lpAmount: BigNumber;
+    lpToken: TokenData;
 }
 export declare class Strategy {
     apy: number | undefined;
@@ -28,11 +36,13 @@ export declare class Strategy {
     leveragableCollateral: Array<string>;
     baseAssets: Array<string>;
     constructor(payload: StrategyPayload);
+    static maxLeverage(lpToken: string, cms: Array<PartialCM>): number;
     maxAPY(maxLeverage: number, poolApy: PoolList): number;
     overallAPY(apy: number, leverage: number, depositCollateral: string, borrowAPY: number): number;
-    liquidationPrice(borrowed: TokenDescription, collateral: TokenDescription, lp: TokenDescription, ltCollateral: BigNumber): BigNumber;
+    liquidationPrice({ assets, prices, tokensList, liquidationThresholds, borrowed, underlyingToken, lpAmount, lpToken, }: LiquidationPriceProps): BigNumber;
     protected farmLev(leverage: number, depositCollateral: string): number;
     protected inBaseAssets(depositCollateral: string): boolean;
     protected inLeveragableAssets(depositCollateral: string): boolean;
 }
+declare type PartialCM = Pick<CreditManagerData, "liquidationThresholds" | "address">;
 export {};

package/lib/core/strategy.js

@@ -14,6 +14,12 @@ var Strategy = /** @class */ (function () {
         this.leveragableCollateral = payload.leveragableCollateral;
         this.baseAssets = payload.baseAssets;
     }
+    Strategy.maxLeverage = function (lpToken, cms) {
+        var maxThreshold = maxLeverageThreshold(lpToken, cms)[0];
+        var ONE = ethers_1.BigNumber.from(constants_1.PERCENTAGE_FACTOR);
+        var maxLeverage = ONE.mul(constants_1.LEVERAGE_DECIMALS).div(ONE.sub(maxThreshold));
+        return maxLeverage.sub(constants_1.LEVERAGE_DECIMALS).toNumber();
+    };
     Strategy.prototype.maxAPY = function (maxLeverage, poolApy) {
         var minApy = minBorrowApy(poolApy);
         return roi(this.apy || 0, maxLeverage, maxLeverage - constants_1.LEVERAGE_DECIMALS, minApy);
@@ -23,14 +29,26 @@ var Strategy = /** @class */ (function () {
         return roi(apy, farmLev, leverage - constants_1.LEVERAGE_DECIMALS, borrowAPY);
     };
     // eslint-disable-next-line class-methods-use-this
-    Strategy.prototype.liquidationPrice = function (borrowed, collateral, lp, ltCollateral) {
-        var borrowedMoney = (0, price_1.calcTotalPrice)(borrowed.price, borrowed.amount, borrowed.decimals);
-        var collateralMoney = (0, price_1.calcTotalPrice)(collateral.price, collateral.amount, collateral.decimals)
-            .mul(ltCollateral)
-            .div(constants_1.PERCENTAGE_FACTOR);
-        var lpMoney = (0, price_1.calcTotalPrice)(lp.price, lp.amount, lp.decimals);
+    Strategy.prototype.liquidationPrice = function (_a) {
+        var assets = _a.assets, prices = _a.prices, tokensList = _a.tokensList, liquidationThresholds = _a.liquidationThresholds, borrowed = _a.borrowed, underlyingToken = _a.underlyingToken, lpAmount = _a.lpAmount, lpToken = _a.lpToken;
+        var collateralLTMoney = assets.reduce(function (acc, _a) {
+            var tokenAddress = _a.token, amount = _a.balance;
+            var lt = liquidationThresholds[tokenAddress] || ethers_1.BigNumber.from(0);
+            var price = prices[tokenAddress] || ethers_1.BigNumber.from(0);
+            var token = tokensList[tokenAddress];
+            var money = (0, price_1.calcTotalPrice)(price, amount, token === null || token === void 0 ? void 0 : token.decimals);
+            var ltMoney = money.mul(lt).div(constants_1.PERCENTAGE_FACTOR);
+            return acc.add(ltMoney);
+        }, ethers_1.BigNumber.from(0));
+        var underlyingPrice = prices[(underlyingToken === null || underlyingToken === void 0 ? void 0 : underlyingToken.address) || ""] || constants_1.PRICE_DECIMALS;
+        var borrowedMoney = (0, price_1.calcTotalPrice)(underlyingPrice, borrowed, underlyingToken === null || underlyingToken === void 0 ? void 0 : underlyingToken.decimals);
+        var lpPrice = prices[(lpToken === null || lpToken === void 0 ? void 0 : lpToken.address) || ""] || constants_1.PRICE_DECIMALS;
+        var lpMoney = (0, price_1.calcTotalPrice)(lpPrice, lpAmount, lpToken === null || lpToken === void 0 ? void 0 : lpToken.decimals);
         if (lpMoney.gt(0)) {
-            var lqPrice = borrowedMoney.sub(collateralMoney).mul(constants_1.WAD).div(lpMoney);
+            var lqPrice = borrowedMoney
+                .sub(collateralLTMoney)
+                .mul(constants_1.WAD)
+                .div(lpMoney);
             return lqPrice.gte(0) ? lqPrice : ethers_1.BigNumber.from(0);
         }
         return ethers_1.BigNumber.from(0);
@@ -57,3 +75,20 @@ function minBorrowApy(poolApy) {
     var apys = Object.values(poolApy).sort(function (a, b) { return a.borrowRate - b.borrowRate; });
     return apys.length > 0 ? apys[0].borrowRate : 0;
 }
+function maxLeverageThreshold(lpToken, cms) {
+    var ltByCM = cms.map(function (cm) {
+        var lt = cm.liquidationThresholds[lpToken] || ethers_1.BigNumber.from(0);
+        return [cm.address, lt];
+    });
+    var sorted = ltByCM.sort(function (_a, _b) {
+        var ltA = _a[1];
+        var ltB = _b[1];
+        if (ltA.gt(ltB))
+            return 1;
+        if (ltB.gt(ltA))
+            return -1;
+        return 0;
+    });
+    var _a = sorted[0] || [], _b = _a[0], cm = _b === void 0 ? "" : _b, _c = _a[1], lt = _c === void 0 ? ethers_1.BigNumber.from(0) : _c;
+    return [lt, cm];
+}

package/lib/core/trade.d.ts

@@ -0,0 +1,49 @@
+import { BigNumber, Signer } from "ethers";
+import { AdapterInterface } from "../contracts/adapters";
+import { SwapType } from "../pathfinder/tradeTypes";
+import { TokenData } from "../tokens/tokenData";
+import { PathFinderResultStructOutput } from "../types/contracts/pathfinder/interfaces/IPathFinder";
+import { BaseAdapter } from "./adapter";
+import { EVMTx } from "./eventOrTx";
+export interface BaseTradeInterface {
+    swapType: SwapType;
+    expectedAmount: BigNumber;
+    rate: BigNumber;
+    tokenFrom: string;
+    tokenTo: string;
+    operationName: string;
+}
+export interface TradeProps {
+    adapter: BaseAdapter;
+    tradePath: PathFinderResultStructOutput;
+    swapType: SwapType;
+    expectedAmount: BigNumber;
+    rate: BigNumber;
+    tokenFrom: string;
+    tokenTo: string;
+    operationName: string;
+}
+export interface ConnectTradeProps {
+    adapter: BaseAdapter;
+    tradePath: PathFinderResultStructOutput;
+}
+export declare class Trade implements BaseTradeInterface {
+    protected helper: BaseAdapter;
+    protected tradePath: PathFinderResultStructOutput;
+    readonly swapType: SwapType;
+    readonly expectedAmount: BigNumber;
+    readonly rate: BigNumber;
+    readonly tokenFrom: string;
+    readonly tokenTo: string;
+    readonly operationName: string;
+    constructor({ tradePath, adapter }: TradeProps);
+    static connect({ tradePath, adapter }: ConnectTradeProps): Trade;
+    getName(): string;
+    getAdapterInterface(): AdapterInterface;
+    getContractAddress(): string;
+    getAdapterAddress(): string;
+    execute(slippage: number, signer: Signer): Promise<EVMTx>;
+    toString(tokenData: Record<string, TokenData>): string;
+    getFromAmount(slippage: number): BigNumber;
+    getToAmount(slippage: number): BigNumber;
+}

package/lib/core/trade.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trade = void 0;
+var ethers_1 = require("ethers");
+var tradeTypes_1 = require("../pathfinder/tradeTypes");
+var formatter_1 = require("../utils/formatter");
+var adapter_1 = require("./adapter");
+var constants_1 = require("./constants");
+var Trade = /** @class */ (function () {
+    function Trade(_a) {
+        var tradePath = _a.tradePath, adapter = _a.adapter;
+        this.helper = adapter;
+        this.tradePath = tradePath;
+        this.swapType = tradeTypes_1.SwapType.ExactInput;
+        this.expectedAmount = ethers_1.BigNumber.from(0);
+        this.rate = ethers_1.BigNumber.from(0);
+        this.tokenFrom = "";
+        this.tokenTo = "";
+        this.operationName = "";
+    }
+    Trade.connect = function (_a) {
+        var tradePath = _a.tradePath, adapter = _a.adapter;
+        return new Trade({
+            tradePath: tradePath,
+            adapter: adapter,
+            swapType: tradeTypes_1.SwapType.ExactInput,
+            expectedAmount: ethers_1.BigNumber.from(0),
+            rate: ethers_1.BigNumber.from(0),
+            tokenFrom: "",
+            tokenTo: "",
+            operationName: "",
+        });
+    };
+    Trade.prototype.getName = function () {
+        return this.helper.name;
+    };
+    Trade.prototype.getAdapterInterface = function () {
+        return this.helper.adapterInterface;
+    };
+    Trade.prototype.getContractAddress = function () {
+        return this.helper.contractAddress;
+    };
+    Trade.prototype.getAdapterAddress = function () {
+        return this.helper.adapterAddress;
+    };
+    Trade.prototype.execute = function (slippage, signer) {
+        return this.helper.execute({ tradePath: this.tradePath, slippage: slippage, signer: signer });
+    };
+    Trade.prototype.toString = function (tokenData) {
+        var result = this.helper.type === adapter_1.AdapterType.Swap
+            ? "Swap "
+            : "".concat(this.operationName || "Farm", " ");
+        var fromToken = tokenData[this.tokenFrom];
+        var toToken = tokenData[this.tokenTo];
+        result += "".concat((0, formatter_1.formatBN)(this.tradePath.amount, fromToken.decimals), " ").concat(fromToken.symbol, " \u21D2 ").concat((0, formatter_1.formatBN)(this.expectedAmount, toToken.decimals), " ").concat(toToken.symbol, " on ").concat(this.helper.name);
+        return result;
+    };
+    Trade.prototype.getFromAmount = function (slippage) {
+        return this.expectedAmount
+            .mul(constants_1.PERCENTAGE_FACTOR)
+            .div(constants_1.PERCENTAGE_FACTOR + slippage);
+    };
+    Trade.prototype.getToAmount = function (slippage) {
+        return this.expectedAmount
+            .mul(constants_1.PERCENTAGE_FACTOR + slippage)
+            .div(constants_1.PERCENTAGE_FACTOR);
+    };
+    return Trade;
+}());
+exports.Trade = Trade;

package/lib/core/wcOperation.d.ts

@@ -0,0 +1,54 @@
+import type { TransactionRequest } from "@ethersproject/abstract-provider";
+import { BigNumber, BytesLike } from "ethers";
+import { FunctionFragment } from "ethers/lib/utils";
+export declare type TxType = "unsupported" | "swap" | "approve" | "lp";
+export declare type LpOperationType = "withdraw" | "deposit";
+export interface RawTransaction {
+    id: number;
+    method: "eth_sendTransaction";
+    params: [TransactionRequest];
+}
+export interface TxInfo {
+    from?: string;
+    to?: string;
+    amountFrom?: BigNumber;
+    amountTo?: BigNumber;
+    functionFragment: FunctionFragment;
+}
+export declare class SwapOperation {
+    readonly id: number;
+    operation?: string;
+    from?: string;
+    to?: string;
+    amountFrom?: BigNumber;
+    amountTo?: BigNumber;
+    tx?: TransactionRequest;
+    raw: RawTransaction;
+    kind: TxType;
+    protected calldata?: BytesLike;
+    isPending: boolean;
+    farm?: string;
+    lpOperationType?: LpOperationType;
+    static tokens: Record<string, boolean>;
+    constructor(raw: RawTransaction, kind: TxType);
+    static NewSwapOperation(params: {
+        adapter: string;
+        operation: string;
+        from: string;
+        to: string;
+        amountFrom: BigNumber;
+        amountTo: BigNumber;
+        raw: RawTransaction;
+    }): SwapOperation;
+    static NewLPOperation(params: {
+        adapter: string;
+        operation: string;
+        from: string;
+        amountFrom: BigNumber;
+        farm: string;
+        type: LpOperationType;
+        raw: RawTransaction;
+    }): SwapOperation;
+    static NewUnsupportedOperation(raw: RawTransaction): SwapOperation;
+    static NewApproveOperation(creditManager: string, raw: RawTransaction, token: string): SwapOperation;
+}

package/lib/core/wcOperation.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapOperation = void 0;
+var types_1 = require("../types");
+var SwapOperation = /** @class */ (function () {
+    function SwapOperation(raw, kind) {
+        this.id = raw.id;
+        this.raw = raw;
+        this.kind = kind;
+        this.isPending = false;
+    }
+    SwapOperation.NewSwapOperation = function (params) {
+        var _a, _b;
+        var newOperation = new SwapOperation(params.raw, "swap");
+        newOperation.operation = params.operation;
+        newOperation.from = params.from;
+        newOperation.to = params.to;
+        newOperation.amountFrom = params.amountFrom;
+        newOperation.amountTo = params.amountTo;
+        newOperation.raw = params.raw;
+        newOperation.calldata = (_b = (_a = params.raw) === null || _a === void 0 ? void 0 : _a.params[0]) === null || _b === void 0 ? void 0 : _b.data;
+        newOperation.tx = {
+            to: params.adapter,
+            data: newOperation.calldata,
+        };
+        return newOperation;
+    };
+    SwapOperation.NewLPOperation = function (params) {
+        var _a, _b;
+        var newOperation = new SwapOperation(params.raw, "lp");
+        newOperation.operation = params.operation;
+        newOperation.from = params.from;
+        newOperation.amountFrom = params.amountFrom;
+        newOperation.raw = params.raw;
+        newOperation.calldata = (_b = (_a = params.raw) === null || _a === void 0 ? void 0 : _a.params[0]) === null || _b === void 0 ? void 0 : _b.data;
+        newOperation.farm = params.farm;
+        newOperation.tx = {
+            to: params.adapter,
+            data: newOperation.calldata,
+        };
+        newOperation.lpOperationType = params.type;
+        return newOperation;
+    };
+    SwapOperation.NewUnsupportedOperation = function (raw) {
+        return new SwapOperation(raw, "unsupported");
+    };
+    SwapOperation.NewApproveOperation = function (creditManager, raw, token) {
+        var _a, _b;
+        var operation = new SwapOperation(raw, "approve");
+        operation.to = token;
+        operation.calldata = (_a = raw === null || raw === void 0 ? void 0 : raw.params[0]) === null || _a === void 0 ? void 0 : _a.data;
+        var tokenI = types_1.IERC20__factory.createInterface();
+        try {
+            var spender = tokenI.decodeFunctionData("approve", ((_b = raw === null || raw === void 0 ? void 0 : raw.params[0]) === null || _b === void 0 ? void 0 : _b.data) || "")[0];
+            var cmi = types_1.ICreditManager__factory.createInterface();
+            operation.from = spender;
+            // @ts-ignore
+            operation.calldata = cmi.encodeFunctionData("approve", [
+                spender,
+                operation.to,
+            ]);
+            operation.tx = {
+                to: creditManager,
+                data: operation.calldata,
+            };
+            return operation;
+        }
+        catch (e) {
+            console.error(e);
+            return SwapOperation.NewUnsupportedOperation(raw);
+        }
+    };
+    SwapOperation.tokens = {};
+    return SwapOperation;
+}());
+exports.SwapOperation = SwapOperation;

package/lib/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./contracts/contracts";
 export * from "./contracts/protocols";
+export * from "./core/adapter";
+export * from "./core/assets";
 export * from "./core/constants";
 export * from "./core/creditAccount";
 export * from "./core/creditManager";
@@ -11,7 +13,9 @@ export * from "./core/operations";
 export * from "./core/pool";
 export * from "./core/strategy";
 export * from "./core/tokenDistributor";
+export * from "./core/trade";
 export * from "./core/transactions";
+export * from "./core/wcOperation";
 export * from "./oracles/oracles";
 export * from "./oracles/priceFeeds";
 export * from "./payload/creditAccount";

package/lib/index.js

@@ -17,6 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.callRepeater = exports.swapKeyValue = exports.objectEntries = exports.keyToLowercase = exports.getUnderlyingToken = exports.getPoolTokens = exports.TokenType = exports.getContractName = exports.AdapterInterface = void 0;
 __exportStar(require("./contracts/contracts"), exports);
 __exportStar(require("./contracts/protocols"), exports);
+__exportStar(require("./core/adapter"), exports);
+__exportStar(require("./core/assets"), exports);
 __exportStar(require("./core/constants"), exports);
 __exportStar(require("./core/creditAccount"), exports);
 __exportStar(require("./core/creditManager"), exports);
@@ -28,7 +30,9 @@ __exportStar(require("./core/operations"), exports);
 __exportStar(require("./core/pool"), exports);
 __exportStar(require("./core/strategy"), exports);
 __exportStar(require("./core/tokenDistributor"), exports);
+__exportStar(require("./core/trade"), exports);
 __exportStar(require("./core/transactions"), exports);
+__exportStar(require("./core/wcOperation"), exports);
 __exportStar(require("./oracles/oracles"), exports);
 __exportStar(require("./oracles/priceFeeds"), exports);
 __exportStar(require("./payload/creditAccount"), exports);

package/lib/utils/math.d.ts

@@ -4,3 +4,4 @@ export declare function rayMul(a: BigNumber, b: BigNumber): BigNumber;
 export declare function rayDiv(a: BigNumber, b: BigNumber): BigNumber;
 export declare function percentMul(a: BigNumber, b: number): BigNumber;
 export declare function sqrt(x: BigNumber): BigNumber;
+export declare const nonNegativeBn: (v: BigNumber) => BigNumber;

package/lib/utils/math.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqrt = exports.percentMul = exports.rayDiv = exports.rayMul = exports.revertRay = void 0;
+exports.nonNegativeBn = exports.sqrt = exports.percentMul = exports.rayDiv = exports.rayMul = exports.revertRay = void 0;
 var ethers_1 = require("ethers");
 var constants_1 = require("../core/constants");
 var ONE = ethers_1.BigNumber.from(1);
@@ -42,3 +42,7 @@ function sqrt(x) {
     return y;
 }
 exports.sqrt = sqrt;
+var nonNegativeBn = function (v) {
+    return v.isNegative() ? ethers_1.BigNumber.from(0) : v;
+};
+exports.nonNegativeBn = nonNegativeBn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",