@gearbox-protocol/sdk 1.22.4 → 1.23.1

package/lib/core/strategy.js

@@ -1,93 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Strategy = void 0;
-var ethers_1 = require("ethers");
-var decimals_1 = require("../tokens/decimals");
-var token_1 = require("../tokens/token");
-var price_1 = require("../utils/price");
-var constants_1 = require("./constants");
-var Strategy = /** @class */ (function () {
-    function Strategy(payload) {
+const decimals_1 = require("../tokens/decimals");
+const token_1 = require("../tokens/token");
+const price_1 = require("../utils/price");
+const constants_1 = require("./constants");
+class Strategy {
+    apy;
+    name;
+    lpToken;
+    pools;
+    unleveragableCollateral;
+    leveragableCollateral;
+    baseAssets;
+    constructor(payload) {
         this.apy = payload.apy;
         this.name = payload.name;
         this.lpToken = payload.lpToken.toLowerCase();
-        this.pools = payload.pools.map(function (addr) { return addr.toLowerCase(); });
-        this.unleveragableCollateral = payload.unleveragableCollateral.map(function (addr) {
-            return addr.toLowerCase();
-        });
-        this.leveragableCollateral = payload.leveragableCollateral.map(function (addr) {
-            return addr.toLowerCase();
-        });
-        this.baseAssets = payload.baseAssets.map(function (addr) { return addr.toLowerCase(); });
+        this.pools = payload.pools.map(addr => addr.toLowerCase());
+        this.unleveragableCollateral = payload.unleveragableCollateral.map(addr => addr.toLowerCase());
+        this.leveragableCollateral = payload.leveragableCollateral.map(addr => addr.toLowerCase());
+        this.baseAssets = payload.baseAssets.map(addr => addr.toLowerCase());
     }
-    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 (baseAPY, maxLeverage, borrowAPY) {
+    static maxLeverage(lpToken, cms) {
+        const [maxThreshold] = maxLeverageThreshold(lpToken, cms);
+        const maxLeverage = (constants_1.PERCENTAGE_FACTOR * constants_1.LEVERAGE_DECIMALS) /
+            (constants_1.PERCENTAGE_FACTOR - maxThreshold);
+        return Number(maxLeverage - constants_1.LEVERAGE_DECIMALS);
+    }
+    maxAPY(baseAPY, maxLeverage, borrowAPY) {
         return (baseAPY +
-            ((baseAPY - borrowAPY) * (maxLeverage - constants_1.LEVERAGE_DECIMALS)) /
-                constants_1.LEVERAGE_DECIMALS);
-    };
-    Strategy.prototype.overallAPY = function (apy, leverage, depositCollateral, borrowAPY) {
-        var farmLev = this.farmLev(leverage, depositCollateral);
-        return roi(apy, farmLev, leverage - constants_1.LEVERAGE_DECIMALS, borrowAPY);
-    };
-    Strategy.liquidationPrice = function (_a) {
-        var prices = _a.prices, liquidationThresholds = _a.liquidationThresholds, borrowed = _a.borrowed, underlyingToken = _a.underlyingToken, lpAmount = _a.lpAmount, lpToken = _a.lpToken;
-        var underlyingTokenAddressLC = underlyingToken.toLowerCase();
-        var underlyingTokenSymbol = token_1.tokenSymbolByAddress[underlyingTokenAddressLC];
-        var underlyingTokenDecimals = decimals_1.decimals[underlyingTokenSymbol];
-        var underlyingPrice = prices[underlyingTokenAddressLC] || constants_1.PRICE_DECIMALS;
-        var borrowedMoney = (0, price_1.calcTotalPrice)(underlyingPrice, borrowed, underlyingTokenDecimals);
-        var lpTokenAddressLC = lpToken.toLowerCase();
-        var lpTokenSymbol = token_1.tokenSymbolByAddress[lpTokenAddressLC];
-        var lpTokenDecimals = decimals_1.decimals[lpTokenSymbol];
-        var lpLT = liquidationThresholds[lpTokenAddressLC] || ethers_1.BigNumber.from(0);
-        var lpPrice = prices[lpTokenAddressLC] || constants_1.PRICE_DECIMALS;
-        var lpMoney = (0, price_1.calcTotalPrice)(lpPrice, lpAmount, lpTokenDecimals);
-        var lpLTMoney = lpMoney.mul(lpLT).div(constants_1.PERCENTAGE_FACTOR);
-        if (lpLTMoney.gt(0)) {
-            var lqPrice = borrowedMoney.mul(constants_1.WAD).div(lpLTMoney);
-            return lqPrice.gte(0) ? lqPrice : ethers_1.BigNumber.from(0);
+            ((baseAPY - borrowAPY) * (maxLeverage - Number(constants_1.LEVERAGE_DECIMALS))) /
+                Number(constants_1.LEVERAGE_DECIMALS));
+    }
+    overallAPY(apy, leverage, depositCollateral, borrowAPY) {
+        const farmLev = this.farmLev(leverage, depositCollateral);
+        return roi(apy, farmLev, leverage - Number(constants_1.LEVERAGE_DECIMALS), borrowAPY);
+    }
+    static liquidationPrice({ prices, liquidationThresholds, borrowed, underlyingToken, lpAmount, lpToken, }) {
+        const underlyingTokenAddressLC = underlyingToken.toLowerCase();
+        const underlyingTokenSymbol = token_1.tokenSymbolByAddress[underlyingTokenAddressLC];
+        const underlyingTokenDecimals = decimals_1.decimals[underlyingTokenSymbol];
+        const underlyingPrice = prices[underlyingTokenAddressLC] || constants_1.PRICE_DECIMALS;
+        const borrowedMoney = (0, price_1.calcTotalPrice)(underlyingPrice, borrowed, underlyingTokenDecimals);
+        const lpTokenAddressLC = lpToken.toLowerCase();
+        const lpTokenSymbol = token_1.tokenSymbolByAddress[lpTokenAddressLC];
+        const lpTokenDecimals = decimals_1.decimals[lpTokenSymbol];
+        const lpLT = liquidationThresholds[lpTokenAddressLC] || 0n;
+        const lpPrice = prices[lpTokenAddressLC] || constants_1.PRICE_DECIMALS;
+        const lpMoney = (0, price_1.calcTotalPrice)(lpPrice, lpAmount, lpTokenDecimals);
+        const lpLTMoney = (lpMoney * lpLT) / constants_1.PERCENTAGE_FACTOR;
+        if (lpLTMoney > 0) {
+            const lqPrice = (borrowedMoney * constants_1.WAD) / lpLTMoney;
+            return lqPrice >= 0 ? lqPrice : 0n;
         }
-        return ethers_1.BigNumber.from(0);
-    };
-    Strategy.prototype.farmLev = function (leverage, depositCollateral) {
+        return 0n;
+    }
+    farmLev(leverage, depositCollateral) {
         return this.inBaseAssets(depositCollateral) ||
             this.inLeveragableAssets(depositCollateral)
             ? leverage
-            : leverage - constants_1.LEVERAGE_DECIMALS;
-    };
-    Strategy.prototype.inBaseAssets = function (depositCollateral) {
-        return this.baseAssets.some(function (c) { return c === depositCollateral.toLowerCase(); });
-    };
-    Strategy.prototype.inLeveragableAssets = function (depositCollateral) {
-        return this.leveragableCollateral.some(function (c) { return c === depositCollateral.toLowerCase(); });
-    };
-    return Strategy;
-}());
+            : leverage - Number(constants_1.LEVERAGE_DECIMALS);
+    }
+    inBaseAssets(depositCollateral) {
+        return this.baseAssets.some(c => c === depositCollateral.toLowerCase());
+    }
+    inLeveragableAssets(depositCollateral) {
+        return this.leveragableCollateral.some(c => c === depositCollateral.toLowerCase());
+    }
+}
 exports.Strategy = Strategy;
 function roi(apy, farmLev, debtLev, borrowAPY) {
-    return (apy * farmLev - borrowAPY * debtLev) / constants_1.LEVERAGE_DECIMALS;
+    return (apy * farmLev - borrowAPY * debtLev) / Number(constants_1.LEVERAGE_DECIMALS);
 }
 function maxLeverageThreshold(lpToken, cms) {
-    var lpTokenLC = lpToken.toLowerCase();
-    var ltByCM = cms.map(function (cm) {
-        var lt = cm.liquidationThresholds[lpTokenLC] || ethers_1.BigNumber.from(0);
+    const lpTokenLC = lpToken.toLowerCase();
+    const ltByCM = cms.map(cm => {
+        const lt = cm.liquidationThresholds[lpTokenLC] || 0n;
         return [cm.address, lt];
     });
-    var sorted = ltByCM.sort(function (_a, _b) {
-        var ltA = _a[1];
-        var ltB = _b[1];
-        if (ltA.gt(ltB))
+    const sorted = ltByCM.sort(([, ltA], [, ltB]) => {
+        if (ltA > ltB)
             return 1;
-        if (ltB.gt(ltA))
+        if (ltB > 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;
+    const [cm = "", lt = 0n] = sorted[0] || [];
     return [lt, cm];
 }

package/lib/core/strategy.spec.js

@@ -1,14 +1,12 @@
 "use strict";
-var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var ethers_1 = require("ethers");
-var decimals_1 = require("../tokens/decimals");
-var token_1 = require("../tokens/token");
-var formatter_1 = require("../utils/formatter");
-var constants_1 = require("./constants");
-var strategy_1 = require("./strategy");
-var lidoPayload = {
+const chai_1 = require("chai");
+const decimals_1 = require("../tokens/decimals");
+const token_1 = require("../tokens/token");
+const formatter_1 = require("../utils/formatter");
+const constants_1 = require("./constants");
+const strategy_1 = require("./strategy");
+const lidoPayload = {
     name: "Lido",
     lpToken: token_1.tokenDataByNetwork.Mainnet.STETH,
     apy: 38434,
@@ -21,8 +19,8 @@ var lidoPayload = {
     leveragableCollateral: [],
     baseAssets: [token_1.tokenDataByNetwork.Mainnet.WETH],
 };
-var lidoStrategy = new strategy_1.Strategy(lidoPayload);
-var pools = {
+const lidoStrategy = new strategy_1.Strategy(lidoPayload);
+const pools = {
     "0x1": {
         borrowRate: 27543,
     },
@@ -30,29 +28,29 @@ var pools = {
         borrowRate: 5736,
     },
 };
-var prices = (_a = {},
-    _a[token_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()] = (0, formatter_1.toBN)("1738.11830000", constants_1.PRICE_DECIMALS_POW),
-    _a[token_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()] = (0, formatter_1.toBN)("0.99941103", constants_1.PRICE_DECIMALS_POW),
-    _a[token_1.tokenDataByNetwork.Mainnet.STETH.toLowerCase()] = (0, formatter_1.toBN)("1703.87588096", constants_1.PRICE_DECIMALS_POW),
-    _a);
-var liquidationThresholds = (_b = {},
-    _b[token_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()] = ethers_1.BigNumber.from("9300"),
-    _b[token_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()] = ethers_1.BigNumber.from("8500"),
-    _b[token_1.tokenDataByNetwork.Mainnet.STETH.toLowerCase()] = ethers_1.BigNumber.from("9000"),
-    _b);
-describe("Strategy test", function () {
-    it("maxAPY calculation is correct", function () {
-        var result = lidoStrategy.maxAPY(53203, 10 * constants_1.LEVERAGE_DECIMALS, pools["0x1"].borrowRate);
+const prices = {
+    [token_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: (0, formatter_1.toBN)("1738.11830000", constants_1.PRICE_DECIMALS_POW),
+    [token_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: (0, formatter_1.toBN)("0.99941103", constants_1.PRICE_DECIMALS_POW),
+    [token_1.tokenDataByNetwork.Mainnet.STETH.toLowerCase()]: (0, formatter_1.toBN)("1703.87588096", constants_1.PRICE_DECIMALS_POW),
+};
+const liquidationThresholds = {
+    [token_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: 9300n,
+    [token_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: 8500n,
+    [token_1.tokenDataByNetwork.Mainnet.STETH.toLowerCase()]: 9000n,
+};
+describe("Strategy test", () => {
+    it("maxAPY calculation is correct", () => {
+        const result = lidoStrategy.maxAPY(53203, 10 * Number(constants_1.LEVERAGE_DECIMALS), pools["0x1"].borrowRate);
         (0, chai_1.expect)(result).to.be.eq(284143);
     });
-    it("overallAPY calculation is correct", function () {
-        var result = lidoStrategy.overallAPY(lidoStrategy.apy || 0, 10 * constants_1.LEVERAGE_DECIMALS, token_1.tokenDataByNetwork.Mainnet.WETH, pools["0x2"].borrowRate);
+    it("overallAPY calculation is correct", () => {
+        const result = lidoStrategy.overallAPY(lidoStrategy.apy || 0, 10 * Number(constants_1.LEVERAGE_DECIMALS), token_1.tokenDataByNetwork.Mainnet.WETH, pools["0x2"].borrowRate);
         (0, chai_1.expect)(result).to.be.eq(332716);
     });
-    it("liquidationPrice calculation is correct", function () {
-        var result = strategy_1.Strategy.liquidationPrice({
-            liquidationThresholds: liquidationThresholds,
-            prices: prices,
+    it("liquidationPrice calculation is correct", () => {
+        const result = strategy_1.Strategy.liquidationPrice({
+            liquidationThresholds,
+            prices,
             borrowed: (0, formatter_1.toBN)("350", decimals_1.decimals.WETH),
             underlyingToken: token_1.tokenDataByNetwork.Mainnet.WETH,
             lpAmount: (0, formatter_1.toBN)("400", decimals_1.decimals.STETH),
@@ -60,10 +58,10 @@ describe("Strategy test", function () {
         });
         (0, chai_1.expect)(Number((0, formatter_1.toSignificant)(result, constants_1.WAD_DECIMALS_POW)).toFixed(3)).to.be.eq("0.992");
     });
-    it("maxLeverage is correct", function () {
-        var result = strategy_1.Strategy.maxLeverage(token_1.tokenDataByNetwork.Mainnet.STETH, [
-            { address: "0x1", liquidationThresholds: liquidationThresholds },
+    it("maxLeverage is correct", () => {
+        const result = strategy_1.Strategy.maxLeverage(token_1.tokenDataByNetwork.Mainnet.STETH, [
+            { address: "0x1", liquidationThresholds },
         ]);
-        (0, chai_1.expect)(result).to.be.eq(9 * constants_1.LEVERAGE_DECIMALS);
+        (0, chai_1.expect)(result).to.be.eq(9 * Number(constants_1.LEVERAGE_DECIMALS));
     });
 });

package/lib/core/tokenDistributor.d.ts

@@ -1,7 +1,6 @@
-import { BigNumber } from "ethers";
 export interface TokenShare {
     holder: string;
-    amount: BigNumber;
+    amount: bigint;
     share: number;
     isCompany: boolean;
 }

package/lib/core/trade.d.ts

@@ -1,4 +1,4 @@
-import { BigNumber, Signer } from "ethers";
+import { Signer } from "ethers";
 import { AdapterInterface } from "../contracts/adapters";
 import { MultiCall, PathFinderResult, SwapOperation } from "../pathfinder/core";
 import { ICreditFacade } from "../types";
@@ -6,8 +6,8 @@ import { BaseAdapter } from "./adapter";
 import { EVMTx } from "./eventOrTx";
 interface BaseTradeInterface {
     swapType: SwapOperation;
-    sourceAmount: BigNumber;
-    expectedAmount: BigNumber;
+    sourceAmount: bigint;
+    expectedAmount: bigint;
     tokenFrom: string;
     tokenTo: string;
     operationName: TradeOperations;
@@ -23,9 +23,9 @@ export declare class Trade implements BaseTradeInterface {
     readonly tradePath: PathFinderResult;
     readonly creditFacade: string;
     readonly swapType: SwapOperation;
-    readonly sourceAmount: BigNumber;
-    readonly expectedAmount: BigNumber;
-    readonly rate: BigNumber;
+    readonly sourceAmount: bigint;
+    readonly expectedAmount: bigint;
+    readonly rate: bigint;
     readonly tokenFrom: string;
     readonly tokenTo: string;
     readonly operationName: TradeOperations;

package/lib/core/trade.js

@@ -1,122 +1,87 @@
 "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 (g && (g = 0, op[0] && (_ = 0)), _) 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.Trade = void 0;
-var decimals_1 = require("../tokens/decimals");
-var token_1 = require("../tokens/token");
-var types_1 = require("../types");
-var formatter_1 = require("../utils/formatter");
-var constants_1 = require("./constants");
-var transactions_1 = require("./transactions");
-var OPERATION_NAMES = {
+const decimals_1 = require("../tokens/decimals");
+const token_1 = require("../tokens/token");
+const types_1 = require("../types");
+const formatter_1 = require("../utils/formatter");
+const constants_1 = require("./constants");
+const transactions_1 = require("./transactions");
+const OPERATION_NAMES = {
     farmWithdraw: "Farm withdraw",
     farmDeposit: "Farm deposit",
     swap: "Swap",
     unknownOperation: "Unknown operation",
 };
-var Trade = /** @class */ (function () {
-    function Trade(props) {
+class Trade {
+    helper;
+    tradePath;
+    creditFacade;
+    swapType;
+    sourceAmount;
+    expectedAmount;
+    rate;
+    tokenFrom;
+    tokenTo;
+    operationName;
+    constructor(props) {
         this.helper = props.adapter;
         this.tradePath = props.tradePath;
         this.creditFacade = props.creditFacade;
         this.swapType = props.swapType;
         this.sourceAmount = props.sourceAmount;
         this.expectedAmount = props.expectedAmount;
-        this.rate = constants_1.WAD.mul(props.expectedAmount).div(props.sourceAmount);
+        this.rate = (constants_1.WAD * props.expectedAmount) / props.sourceAmount;
         this.tokenFrom = props.tokenFrom;
         this.tokenTo = props.tokenTo;
         this.operationName = props.operationName;
     }
-    Trade.prototype.getName = function () {
+    getName() {
         return this.helper.name;
-    };
-    Trade.prototype.getAdapterInterface = function () {
+    }
+    getAdapterInterface() {
         return this.helper.adapterInterface;
-    };
-    Trade.prototype.getContractAddress = function () {
+    }
+    getContractAddress() {
         return this.helper.contractAddress;
-    };
-    Trade.prototype.getAdapterAddress = function () {
+    }
+    getAdapterAddress() {
         return this.helper.adapterAddress;
-    };
-    Trade.prototype.execute = function (signer) {
-        return __awaiter(this, void 0, void 0, function () {
-            var receipt;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Trade.executeMulticallPath(this.creditFacade, signer, this.tradePath.calls)];
-                    case 1:
-                        receipt = _a.sent();
-                        return [2 /*return*/, new transactions_1.TXSwap({
-                                txHash: receipt.hash,
-                                protocol: this.helper.contractAddress,
-                                operation: OPERATION_NAMES[this.operationName],
-                                amountFrom: this.sourceAmount,
-                                amountTo: this.expectedAmount,
-                                tokenFrom: this.tokenFrom,
-                                tokenTo: this.tokenTo,
-                                creditManager: this.helper.creditManager,
-                                timestamp: 0,
-                            })];
-                }
-            });
+    }
+    async execute(signer) {
+        const receipt = await Trade.executeMulticallPath(this.creditFacade, signer, this.tradePath.calls);
+        return new transactions_1.TXSwap({
+            txHash: receipt.hash,
+            protocol: this.helper.contractAddress,
+            operation: OPERATION_NAMES[this.operationName],
+            amountFrom: this.sourceAmount,
+            amountTo: this.expectedAmount,
+            tokenFrom: this.tokenFrom,
+            tokenTo: this.tokenTo,
+            creditManager: this.helper.creditManager,
+            timestamp: 0,
         });
-    };
-    Trade.prototype.toString = function () {
-        var symbolFrom = token_1.tokenSymbolByAddress[this.tokenFrom.toLowerCase()];
-        var symbolTo = token_1.tokenSymbolByAddress[this.tokenTo.toLowerCase()];
+    }
+    toString() {
+        const symbolFrom = token_1.tokenSymbolByAddress[this.tokenFrom.toLowerCase()];
+        const symbolTo = token_1.tokenSymbolByAddress[this.tokenTo.toLowerCase()];
         if (!symbolFrom)
-            throw new Error("Unknown token: ".concat(this.tokenFrom));
+            throw new Error(`Unknown token: ${this.tokenFrom}`);
         if (!symbolTo)
-            throw new Error("Unknown token: ".concat(this.tokenTo));
-        var decimalsFrom = decimals_1.decimals[symbolFrom];
-        var decimalsTo = decimals_1.decimals[symbolTo];
-        return "".concat(this.operationName, " ").concat((0, formatter_1.formatBN)(this.sourceAmount, decimalsFrom), " ").concat(symbolFrom, " \u21D2 ").concat((0, formatter_1.formatBN)(this.expectedAmount, decimalsTo), " ").concat(symbolTo, " on ").concat(this.helper.name);
-    };
-    Trade.getOperationName = function (tokenInAddress, tokenOutAddress) {
-        var tokenInSymbol = token_1.tokenSymbolByAddress[tokenInAddress];
-        var tokenOutSymbol = token_1.tokenSymbolByAddress[tokenOutAddress];
-        var tokenInIsLp = (0, token_1.isLPToken)(tokenInSymbol);
-        var tokenOutIsLp = (0, token_1.isLPToken)(tokenOutSymbol);
+            throw new Error(`Unknown token: ${this.tokenTo}`);
+        const decimalsFrom = decimals_1.decimals[symbolFrom];
+        const decimalsTo = decimals_1.decimals[symbolTo];
+        return `${this.operationName} ${(0, formatter_1.formatBN)(this.sourceAmount, decimalsFrom)} ${symbolFrom} ⇒ ${(0, formatter_1.formatBN)(this.expectedAmount, decimalsTo)} ${symbolTo} on ${this.helper.name}`;
+    }
+    static getOperationName(tokenInAddress, tokenOutAddress) {
+        const tokenInSymbol = token_1.tokenSymbolByAddress[tokenInAddress];
+        const tokenOutSymbol = token_1.tokenSymbolByAddress[tokenOutAddress];
+        const tokenInIsLp = (0, token_1.isLPToken)(tokenInSymbol);
+        const tokenOutIsLp = (0, token_1.isLPToken)(tokenOutSymbol);
         if (!tokenInSymbol)
-            throw new Error("Unknown token: ".concat(tokenInAddress));
+            throw new Error(`Unknown token: ${tokenInAddress}`);
         if (!tokenOutSymbol)
-            throw new Error("Unknown token: ".concat(tokenOutAddress));
+            throw new Error(`Unknown token: ${tokenOutAddress}`);
         if (tokenInIsLp && !tokenOutIsLp)
             return "farmWithdraw";
         if (!tokenInIsLp && tokenOutIsLp)
@@ -124,27 +89,17 @@ var Trade = /** @class */ (function () {
         if (!tokenInIsLp && !tokenOutIsLp)
             return "swap";
         return "unknownOperation";
-    };
-    Trade.executeMulticallPath = function (creditFacade, signer, calls) {
-        return __awaiter(this, void 0, void 0, function () {
-            var safeCreditFacade;
-            return __generator(this, function (_a) {
-                if (calls.length < 1)
-                    throw new Error("No path to execute");
-                safeCreditFacade = typeof creditFacade === "string"
-                    ? types_1.ICreditFacade__factory.connect(creditFacade, signer)
-                    : creditFacade;
-                return [2 /*return*/, this.executeOnCreditFacade(calls, safeCreditFacade)];
-            });
-        });
-    };
-    Trade.executeOnCreditFacade = function (calls, creditFacade) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, creditFacade.multicall(calls)];
-            });
-        });
-    };
-    return Trade;
-}());
+    }
+    static async executeMulticallPath(creditFacade, signer, calls) {
+        if (calls.length < 1)
+            throw new Error("No path to execute");
+        const safeCreditFacade = typeof creditFacade === "string"
+            ? types_1.ICreditFacade__factory.connect(creditFacade, signer)
+            : creditFacade;
+        return this.executeOnCreditFacade(calls, safeCreditFacade);
+    }
+    static async executeOnCreditFacade(calls, creditFacade) {
+        return creditFacade.multicall(calls);
+    }
+}
 exports.Trade = Trade;