@gearbox-protocol/sdk 1.22.3 → 1.23.0

package/lib/parsers/uniV3AdapterParser.spec.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var solidity_1 = require("@ethersproject/solidity");
-var chai_1 = require("chai");
-var ethers_1 = require("ethers");
-var constants_1 = require("../core/constants");
-var token_1 = require("../tokens/token");
-var types_1 = require("../types");
-var uniV3AdapterParser_1 = require("./uniV3AdapterParser");
-var pathToUniV3Path = function (path) {
-    var pathWithFees = [];
-    var types = [];
-    path.forEach(function (p, num) {
+const solidity_1 = require("@ethersproject/solidity");
+const chai_1 = require("chai");
+const constants_1 = require("../core/constants");
+const token_1 = require("../tokens/token");
+const types_1 = require("../types");
+const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
+const pathToUniV3Path = (path) => {
+    const pathWithFees = [];
+    const types = [];
+    path.forEach((p, num) => {
         pathWithFees.push(p);
         types.push("address");
         if (num !== path.length - 1) {
@@ -20,19 +19,19 @@ var pathToUniV3Path = function (path) {
     });
     return (0, solidity_1.pack)(types, pathWithFees);
 };
-describe("UniswapV3AdapterParser test", function () {
-    it("swap functions works well", function () {
-        var parser = new uniV3AdapterParser_1.UniswapV3AdapterParser("UNISWAP_V3_ROUTER", false);
-        var ifc = types_1.IUniswapV3Adapter__factory.createInterface();
-        var parsed = parser.parse(ifc.encodeFunctionData("exactInputSingle", [
+describe("UniswapV3AdapterParser test", () => {
+    it("swap functions works well", () => {
+        let parser = new uniV3AdapterParser_1.UniswapV3AdapterParser("UNISWAP_V3_ROUTER", false);
+        const ifc = types_1.IUniswapV3Adapter__factory.createInterface();
+        let parsed = parser.parse(ifc.encodeFunctionData("exactInputSingle", [
             {
                 tokenIn: token_1.tokenDataByNetwork.Goerli["1INCH"],
                 tokenOut: token_1.tokenDataByNetwork.Goerli["3Crv"],
                 fee: 3000,
                 recipient: constants_1.DUMB_ADDRESS,
                 deadline: 12300,
-                amountIn: constants_1.WAD.mul(1299000),
-                amountOutMinimum: constants_1.WAD.mul(10200),
+                amountIn: constants_1.WAD * 1299000n,
+                amountOutMinimum: constants_1.WAD * 10200n,
                 sqrtPriceLimitX96: 0,
             },
         ]));
@@ -43,7 +42,7 @@ describe("UniswapV3AdapterParser test", function () {
                 tokenOut: token_1.tokenDataByNetwork.Goerli["3Crv"],
                 fee: 3000,
                 deadline: 12300,
-                rateMinRAY: constants_1.RAY.mul(1200),
+                rateMinRAY: constants_1.RAY * 1200n,
                 sqrtPriceLimitX96: 0,
             },
         ]));
@@ -57,8 +56,8 @@ describe("UniswapV3AdapterParser test", function () {
                 ]),
                 recipient: constants_1.DUMB_ADDRESS,
                 deadline: 1232131,
-                amountIn: constants_1.WAD.mul(12399),
-                amountOutMinimum: ethers_1.BigNumber.from(1e6).mul(122),
+                amountIn: constants_1.WAD * 12399n,
+                amountOutMinimum: BigInt(1e6) * 122n,
             },
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactInput(amountIn: 12.39K [12399000000000000000000], amountOutMinimum: 122.00 [122000000],  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
@@ -69,7 +68,7 @@ describe("UniswapV3AdapterParser test", function () {
                     token_1.tokenDataByNetwork.Mainnet.LINK,
                     token_1.tokenDataByNetwork.Mainnet.USDC,
                 ]),
-                rateMinRAY: constants_1.RAY.mul(1200),
+                rateMinRAY: constants_1.RAY * 1200n,
                 deadline: 1232131,
             },
         ]));
@@ -81,7 +80,7 @@ describe("UniswapV3AdapterParser test", function () {
                 fee: 10000,
                 recipient: constants_1.DUMB_ADDRESS,
                 deadline: 12300,
-                amountInMaximum: constants_1.WAD.mul(149).div(1000),
+                amountInMaximum: (constants_1.WAD * 149n) / 1000n,
                 amountOut: 102e6,
                 sqrtPriceLimitX96: 0,
             },
@@ -97,7 +96,7 @@ describe("UniswapV3AdapterParser test", function () {
                 recipient: constants_1.DUMB_ADDRESS,
                 deadline: 1232131,
                 amountInMaximum: 123e6,
-                amountOut: constants_1.WAD.mul(122),
+                amountOut: constants_1.WAD * 122n,
             },
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutput(amountInMaximum: 123.00 [123000000], amountOut: 122.00 [122000000000000000000],  path: USDC ==(fee: 3000)==> LINK ==(fee: 3000)==> AAVE", "Incorrect parse swapExactTokensForTokens");

package/lib/parsers/wstETHAdapterParser.js

@@ -1,68 +1,50 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WstETHAdapterParser = void 0;
-var ethers_1 = require("ethers");
-var types_1 = require("../types");
-var abstractParser_1 = require("./abstractParser");
-var WstETHAdapterParser = /** @class */ (function (_super) {
-    __extends(WstETHAdapterParser, _super);
-    function WstETHAdapterParser(contract, isContract) {
-        var _this = _super.call(this, contract) || this;
-        _this.ifc = !isContract
+const types_1 = require("../types");
+const formatter_1 = require("../utils/formatter");
+const abstractParser_1 = require("./abstractParser");
+class WstETHAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.ifc = !isContract
             ? types_1.IwstETHV1Adapter__factory.createInterface()
             : types_1.IwstETH__factory.createInterface();
         if (!isContract)
-            _this.adapterName = "wstETHAdapter";
-        return _this;
+            this.adapterName = "wstETHAdapter";
     }
-    WstETHAdapterParser.prototype.parse = function (calldata) {
-        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+    parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             case "wrap": {
-                var amount = this.decodeFunctionData(functionFragment, calldata)[0];
-                return "".concat(functionName, "(amount: ").concat(this.formatBN(amount, "STETH"), ")");
+                const [amount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
             }
             case "wrapAll": {
-                return "".concat(functionName, "()");
+                return `${functionName}()`;
             }
             case "unwrap": {
-                var amount = this.decodeFunctionData(functionFragment, calldata)[0];
-                return "".concat(functionName, "(amount: ").concat(this.formatBN(amount, "wstETH"), ")");
+                const [amount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(amount: ${this.formatBN(amount, "wstETH")})`;
             }
             case "unwrapAll": {
-                return "".concat(functionName, "()");
+                return `${functionName}()`;
             }
             case "balanceOf": {
-                var address = this.decodeFunctionData(functionFragment, calldata)[0];
-                return "".concat(functionName, "(").concat(address, ")");
+                const [address] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(${address})`;
             }
             case "allowance": {
-                var _b = this.decodeFunctionData(functionFragment, calldata), account = _b[0], to = _b[1];
-                return "".concat(functionName, "(account: ").concat(account, ", to: ").concat(to, ")");
+                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(account: ${account}, to: ${to})`;
             }
             case "approve": {
-                var _c = this.decodeFunctionData(functionFragment, calldata), spender = _c[0], amount = _c[1];
-                return "".concat(functionName, "(").concat(spender, ", [").concat(ethers_1.BigNumber.from(amount).toString(), "])");
+                const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(${spender}, [${(0, formatter_1.toBigInt)(amount).toString()}])`;
             }
             default:
-                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
         }
-    };
-    return WstETHAdapterParser;
-}(abstractParser_1.AbstractParser));
+    }
+}
 exports.WstETHAdapterParser = WstETHAdapterParser;

package/lib/parsers/wstETHAdapterParser.spec.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var constants_1 = require("../core/constants");
-var types_1 = require("../types");
-var wstETHAdapterParser_1 = require("./wstETHAdapterParser");
-describe("WstETHAdapterParser test", function () {
-    it("wrap / unwrap function works well", function () {
-        var parser = new wstETHAdapterParser_1.WstETHAdapterParser("LIDO_WSTETH", false);
-        var ifc = types_1.IwstETHV1Adapter__factory.createInterface();
-        var parsed = parser.parse(ifc.encodeFunctionData("wrapAll"));
+const chai_1 = require("chai");
+const constants_1 = require("../core/constants");
+const types_1 = require("../types");
+const wstETHAdapterParser_1 = require("./wstETHAdapterParser");
+describe("WstETHAdapterParser test", () => {
+    it("wrap / unwrap function works well", () => {
+        let parser = new wstETHAdapterParser_1.WstETHAdapterParser("LIDO_WSTETH", false);
+        const ifc = types_1.IwstETHV1Adapter__factory.createInterface();
+        let parsed = parser.parse(ifc.encodeFunctionData("wrapAll"));
         (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].wrapAll()", "Incorrect parse wrapAll()");
         parsed = parser.parse(ifc.encodeFunctionData("unwrapAll"));
         (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].unwrapAll()", "Incorrect parse unwrapAll()");
         parser = new wstETHAdapterParser_1.WstETHAdapterParser("LIDO_WSTETH", true);
-        parsed = parser.parse(ifc.encodeFunctionData("wrap", [constants_1.WAD.mul(1020)]));
+        parsed = parser.parse(ifc.encodeFunctionData("wrap", [constants_1.WAD * 1020n]));
         (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_WSTETH].wrap(amount: 1.02K [1020000000000000000000])", "Incorrect parse wrap(amount)");
-        parsed = parser.parse(ifc.encodeFunctionData("unwrap", [constants_1.WAD.mul(1020)]));
+        parsed = parser.parse(ifc.encodeFunctionData("unwrap", [constants_1.WAD * 1020n]));
         (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_WSTETH].unwrap(amount: 1.02K [1020000000000000000000])", "Incorrect parse unwrap(amount)");
     });
 });

package/lib/parsers/yearnAdapterParser.spec.js

@@ -1,36 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var constants_1 = require("../core/constants");
-var types_1 = require("../types");
-var yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
-describe("YearnV2AdapterParser test", function () {
-    it("deposit / withdraw functions works well", function () {
-        var parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
-        var ifc = types_1.IYearnV2Adapter__factory.createInterface();
-        var parsed = parser.parse(ifc.encodeFunctionData("deposit()"));
+const chai_1 = require("chai");
+const constants_1 = require("../core/constants");
+const types_1 = require("../types");
+const yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
+describe("YearnV2AdapterParser test", () => {
+    it("deposit / withdraw functions works well", () => {
+        let parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
+        const ifc = types_1.IYearnV2Adapter__factory.createInterface();
+        let parsed = parser.parse(ifc.encodeFunctionData("deposit()"));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit()", "Incorrect parse deposit()");
-        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256)", [constants_1.WAD.mul(19000)]));
+        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256)", [constants_1.WAD * 19000n]));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000])", "Incorrect parse deposit(amount)");
         parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256,address)", [
-            constants_1.WAD.mul(19000),
+            constants_1.WAD * 19000n,
             constants_1.DUMB_ADDRESS,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ".concat(constants_1.DUMB_ADDRESS, ")"), "Incorrect parse deposit(amount,address)");
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS})`, "Incorrect parse deposit(amount,address)");
         parsed = parser.parse(ifc.encodeFunctionData("withdraw()"));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw()", "Incorrect parse withdraw()");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256)", [constants_1.WAD.mul(19000)]));
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256)", [constants_1.WAD * 19000n]));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000])", "Incorrect parse withdraw(amount)");
         parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address)", [
-            constants_1.WAD.mul(19000),
+            constants_1.WAD * 19000n,
             constants_1.DUMB_ADDRESS,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ".concat(constants_1.DUMB_ADDRESS, ")"), "Incorrect parse withdraw(amount,address)");
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS})`, "Incorrect parse withdraw(amount,address)");
         parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address,uint256)", [
-            constants_1.WAD.mul(19000),
+            constants_1.WAD * 19000n,
             constants_1.DUMB_ADDRESS,
             555,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ".concat(constants_1.DUMB_ADDRESS, ", maxLoss: 555)"), "Incorrect parse withdraw(amount,address,uint256)");
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS}, maxLoss: 555)`, "Incorrect parse withdraw(amount,address,uint256)");
     });
 });

package/lib/parsers/yearnV2AdapterParser.js

@@ -1,65 +1,47 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YearnV2AdapterParser = void 0;
-var contracts_1 = require("../contracts/contracts");
-var types_1 = require("../types");
-var abstractParser_1 = require("./abstractParser");
-var YearnV2AdapterParser = /** @class */ (function (_super) {
-    __extends(YearnV2AdapterParser, _super);
-    function YearnV2AdapterParser(contract, isContract) {
-        var _this = _super.call(this, contract) || this;
-        _this.ifc = types_1.IYVault__factory.createInterface();
+const contracts_1 = require("../contracts/contracts");
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.ifc = types_1.IYVault__factory.createInterface();
         if (!isContract)
-            _this.adapterName = "YearnV2Adapter";
-        return _this;
+            this.adapterName = "YearnV2Adapter";
     }
-    YearnV2AdapterParser.prototype.parse = function (calldata) {
-        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+    parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             case "deposit":
             case "withdraw":
             case "deposit(uint256)":
             case "withdraw(uint256)":
             case "withdraw(uint256,address,uint256)": {
-                var _b = this.decodeFunctionData(functionFragment, calldata), amount = _b[0], address = _b[1], maxLoss = _b[2];
-                var yvSym = this.tokenSymbol(contracts_1.contractsByNetwork.Mainnet[this.contract]);
-                var amountStr = amount
-                    ? "amount: ".concat(this.formatBN(amount, yvSym))
+                const [amount, address, maxLoss] = this.decodeFunctionData(functionFragment, calldata);
+                const yvSym = this.tokenSymbol(contracts_1.contractsByNetwork.Mainnet[this.contract]);
+                const amountStr = amount
+                    ? `amount: ${this.formatBN(amount, yvSym)}`
                     : "";
-                var addressStr = address ? ", address: ".concat(address) : "";
-                var maxLossStr = maxLoss ? ", maxLoss: ".concat(maxLoss) : "";
-                return "".concat(functionName, "(").concat(amountStr).concat(addressStr).concat(maxLossStr, ")");
+                const addressStr = address ? `, address: ${address}` : "";
+                const maxLossStr = maxLoss ? `, maxLoss: ${maxLoss}` : "";
+                return `${functionName}(${amountStr}${addressStr}${maxLossStr})`;
             }
             case "pricePerShare": {
-                return "".concat(functionName, "()");
+                return `${functionName}()`;
             }
             case "balanceOf": {
-                var address = this.decodeFunctionData(functionFragment, calldata)[0];
-                return "".concat(functionName, "(").concat(address, ")");
+                const [address] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(${address})`;
             }
             case "allowance": {
-                var _c = this.decodeFunctionData(functionFragment, calldata), account = _c[0], to = _c[1];
-                return "".concat(functionName, "(account: ").concat(account, ", to: ").concat(to, ")");
+                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(account: ${account}, to: ${to})`;
             }
             default:
-                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
         }
-    };
-    return YearnV2AdapterParser;
-}(abstractParser_1.AbstractParser));
+    }
+}
 exports.YearnV2AdapterParser = YearnV2AdapterParser;

package/lib/pathfinder/core.d.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from "ethers";
 export declare enum SwapOperation {
     EXACT_INPUT = 0,
     EXACT_INPUT_ALL = 1,
@@ -9,14 +8,14 @@ export interface MultiCall {
     callData: string;
 }
 export interface PathFinderResult {
-    amount: BigNumber;
+    amount: bigint;
     calls: Array<MultiCall>;
 }
 export interface PathFinderOpenStrategyResult {
-    balances: Record<string, BigNumber>;
+    balances: Record<string, bigint>;
     calls: Array<MultiCall>;
 }
 export interface PathFinderCloseResult {
-    underlyingBalance: BigNumber;
+    underlyingBalance: bigint;
     calls: Array<MultiCall>;
 }

package/lib/pathfinder/pathOptions.js

@@ -1,39 +1,17 @@
 "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);
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathOptionFactory = void 0;
-var ethers_1 = require("ethers");
-var contracts_1 = require("../contracts/contracts");
-var convex_1 = require("../tokens/convex");
-var curveLP_1 = require("../tokens/curveLP");
-var token_1 = require("../tokens/token");
-var yearn_1 = require("../tokens/yearn");
-var PathOptionFactory = /** @class */ (function () {
-    function PathOptionFactory() {
-    }
-    PathOptionFactory.generatePathOptions = function (balances, loopsInTx) {
-        var curvePools = PathOptionFactory.getCurvePools(balances);
-        var network = PathOptionFactory.detectNetwork(Object.keys(balances)[0]);
-        var initPO = curvePools.map(function (symbol) {
+const contracts_1 = require("../contracts/contracts");
+const convex_1 = require("../tokens/convex");
+const curveLP_1 = require("../tokens/curveLP");
+const token_1 = require("../tokens/token");
+const yearn_1 = require("../tokens/yearn");
+const formatter_1 = require("../utils/formatter");
+class PathOptionFactory {
+    static generatePathOptions(balances, loopsInTx) {
+        const curvePools = PathOptionFactory.getCurvePools(balances);
+        const network = PathOptionFactory.detectNetwork(Object.keys(balances)[0]);
+        const initPO = curvePools.map(symbol => {
             return {
                 target: token_1.tokenDataByNetwork[network][symbol],
                 option: 0,
@@ -41,10 +19,10 @@ var PathOptionFactory = /** @class */ (function () {
                     .tokens.length,
             };
         });
-        var totalLoops = initPO.reduce(function (acc, item) { return acc * item.totalOptions; }, 1);
-        var result = [];
-        var currentPo = __spreadArray([], initPO, true);
-        for (var i = 0; i < totalLoops; i++) {
+        const totalLoops = initPO.reduce((acc, item) => acc * item.totalOptions, 1);
+        const result = [];
+        let currentPo = [...initPO];
+        for (let i = 0; i < totalLoops; i++) {
             if (i % loopsInTx === 0) {
                 result.push(currentPo);
             }
@@ -53,66 +31,40 @@ var PathOptionFactory = /** @class */ (function () {
             }
         }
         return result;
-    };
-    PathOptionFactory.getCurvePools = function (balances) {
-        var curveSymbols = Object.keys(curveLP_1.curveTokens);
-        var curvePools = Object.entries(balances)
-            .filter(function (_a) {
-            var balance = _a[1];
-            return ethers_1.BigNumber.from(balance).gt(1);
-        })
-            .map(function (_a) {
-            var token = _a[0];
-            return token_1.tokenSymbolByAddress[token.toLowerCase()];
-        })
-            .filter(function (symbol) { return curveSymbols.includes(symbol); });
-        var yearnCurveTokens = Object.entries(yearn_1.yearnTokens)
-            .filter(function (_a) {
-            var data = _a[1];
-            return curveSymbols.includes(data.underlying);
-        })
-            .map(function (_a) {
-            var token = _a[0];
-            return token;
-        });
-        var curvePoolsFromYearn = Object.entries(balances)
-            .filter(function (_a) {
-            var balance = _a[1];
-            return ethers_1.BigNumber.from(balance).gt(1);
-        })
-            .map(function (_a) {
-            var token = _a[0];
-            return token_1.tokenSymbolByAddress[token.toLowerCase()];
-        })
-            .filter(function (symbol) { return yearnCurveTokens.includes(symbol); })
-            .map(function (symbol) { return yearn_1.yearnTokens[symbol].underlying; });
-        var convexCurveTokens = Object.entries(convex_1.convexTokens)
-            .filter(function (_a) {
-            var data = _a[1];
-            return curveSymbols.includes(data.underlying);
-        })
-            .map(function (_a) {
-            var token = _a[0];
-            return token;
-        });
-        var curvePoolsFromConvex = Object.entries(balances)
-            .filter(function (_a) {
-            var balance = _a[1];
-            return ethers_1.BigNumber.from(balance).gt(1);
-        })
-            .map(function (_a) {
-            var token = _a[0];
-            return token_1.tokenSymbolByAddress[token.toLowerCase()];
-        })
-            .filter(function (symbol) { return convexCurveTokens.includes(symbol); })
-            .map(function (symbol) { return convex_1.convexTokens[symbol].underlying; });
-        var curveSet = new Set(__spreadArray(__spreadArray(__spreadArray([], curvePools, true), curvePoolsFromYearn, true), curvePoolsFromConvex, true));
+    }
+    static getCurvePools(balances) {
+        const curveSymbols = Object.keys(curveLP_1.curveTokens);
+        const curvePools = Object.entries(balances)
+            .filter(([, balance]) => (0, formatter_1.toBigInt)(balance) > 1)
+            .map(([token]) => token_1.tokenSymbolByAddress[token.toLowerCase()])
+            .filter(symbol => curveSymbols.includes(symbol));
+        const yearnCurveTokens = Object.entries(yearn_1.yearnTokens)
+            .filter(([, data]) => curveSymbols.includes(data.underlying))
+            .map(([token]) => token);
+        const curvePoolsFromYearn = Object.entries(balances)
+            .filter(([, balance]) => (0, formatter_1.toBigInt)(balance) > 1)
+            .map(([token]) => token_1.tokenSymbolByAddress[token.toLowerCase()])
+            .filter(symbol => yearnCurveTokens.includes(symbol))
+            .map(symbol => yearn_1.yearnTokens[symbol].underlying);
+        const convexCurveTokens = Object.entries(convex_1.convexTokens)
+            .filter(([, data]) => curveSymbols.includes(data.underlying))
+            .map(([token]) => token);
+        const curvePoolsFromConvex = Object.entries(balances)
+            .filter(([, balance]) => (0, formatter_1.toBigInt)(balance) > 1)
+            .map(([token]) => token_1.tokenSymbolByAddress[token.toLowerCase()])
+            .filter(symbol => convexCurveTokens.includes(symbol))
+            .map(symbol => convex_1.convexTokens[symbol].underlying);
+        const curveSet = new Set([
+            ...curvePools,
+            ...curvePoolsFromYearn,
+            ...curvePoolsFromConvex,
+        ]);
         return Array.from(curveSet.values());
-    };
-    PathOptionFactory.next = function (path) {
-        var newPath = __spreadArray([], path, true);
-        for (var i = path.length - 1; i >= 0; i--) {
-            var po = __assign({}, newPath[i]);
+    }
+    static next(path) {
+        let newPath = [...path];
+        for (let i = path.length - 1; i >= 0; i--) {
+            const po = { ...newPath[i] };
             po.option++;
             newPath[i] = po;
             if (po.option < po.totalOptions)
@@ -120,12 +72,11 @@ var PathOptionFactory = /** @class */ (function () {
             po.option = 0;
         }
         throw new Error("Path options overflow");
-    };
-    PathOptionFactory.detectNetwork = function (underlying) {
+    }
+    static detectNetwork(underlying) {
         return token_1.tokenDataByNetwork.Mainnet[token_1.tokenSymbolByAddress[underlying.toLowerCase()]].toLowerCase() === underlying.toLowerCase()
             ? "Mainnet"
             : "Goerli";
-    };
-    return PathOptionFactory;
-}());
+    }
+}
 exports.PathOptionFactory = PathOptionFactory;