@gearbox-protocol/sdk 1.22.4 → 1.23.0

package/lib/pathfinder/pathOptions.spec.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var token_1 = require("../tokens/token");
-var pathOptions_1 = require("./pathOptions");
-describe("PathOptionFactory test", function () {
-    it("next works correctly", function () {
-        var serie = [
+const chai_1 = require("chai");
+const token_1 = require("../tokens/token");
+const pathOptions_1 = require("./pathOptions");
+describe("PathOptionFactory test", () => {
+    it("next works correctly", () => {
+        const serie = [
             {
                 target: token_1.tokenDataByNetwork.Mainnet["3Crv"],
                 option: 0,
@@ -22,9 +22,9 @@ describe("PathOptionFactory test", function () {
                 totalOptions: 2,
             },
         ];
-        var expectedNext = JSON.parse(JSON.stringify(serie));
+        const expectedNext = JSON.parse(JSON.stringify(serie));
         expectedNext[2].option = 1;
-        var next = pathOptions_1.PathOptionFactory.next(serie);
+        let next = pathOptions_1.PathOptionFactory.next(serie);
         (0, chai_1.expect)(next).to.be.eql(expectedNext);
         expectedNext[1].option = 1;
         expectedNext[2].option = 0;
@@ -55,17 +55,16 @@ describe("PathOptionFactory test", function () {
         next = pathOptions_1.PathOptionFactory.next(next);
         (0, chai_1.expect)(next).to.be.eql(expectedNext);
     });
-    it("generatePathOptions works correctly", function () {
-        var _a;
-        var balances = (_a = {},
-            _a[token_1.tokenDataByNetwork.Mainnet["1INCH"]] = 100,
-            _a[token_1.tokenDataByNetwork.Mainnet["3Crv"]] = 200,
-            _a[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
-            _a[token_1.tokenDataByNetwork.Mainnet.FRAX3CRV] = 200,
-            _a[token_1.tokenDataByNetwork.Mainnet.LUSD3CRV] = 200,
-            _a);
-        var result = pathOptions_1.PathOptionFactory.generatePathOptions(balances, 4);
-        var expected = [
+    it("generatePathOptions works correctly", () => {
+        const balances = {
+            [token_1.tokenDataByNetwork.Mainnet["1INCH"]]: 100,
+            [token_1.tokenDataByNetwork.Mainnet["3Crv"]]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.USDC]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.FRAX3CRV]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.LUSD3CRV]: 200,
+        };
+        const result = pathOptions_1.PathOptionFactory.generatePathOptions(balances, 4);
+        const expected = [
             {
                 target: token_1.tokenDataByNetwork.Mainnet["3Crv"],
                 option: 0,
@@ -82,62 +81,61 @@ describe("PathOptionFactory test", function () {
                 totalOptions: 2,
             },
         ];
-        for (var i = 0; i < 3; i++) {
+        for (let i = 0; i < 3; i++) {
             expected[0].option = i;
             (0, chai_1.expect)(expected).to.be.eql(result[i]);
         }
     });
-    it(" getCurvePools works correctly", function () {
-        var _a, _b, _c, _d, _e;
-        var balances = (_a = {},
-            _a[token_1.tokenDataByNetwork.Mainnet["1INCH"]] = 100,
-            _a[token_1.tokenDataByNetwork.Mainnet["3Crv"]] = 200,
-            _a[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
-            _a[token_1.tokenDataByNetwork.Mainnet.FRAX3CRV] = 200,
-            _a[token_1.tokenDataByNetwork.Mainnet.LUSD3CRV] = 200,
-            _a);
-        var expectedCurvePools = [
+    it(" getCurvePools works correctly", () => {
+        let balances = {
+            [token_1.tokenDataByNetwork.Mainnet["1INCH"]]: 100,
+            [token_1.tokenDataByNetwork.Mainnet["3Crv"]]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.USDC]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.FRAX3CRV]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.LUSD3CRV]: 200,
+        };
+        let expectedCurvePools = [
             "3Crv",
             "FRAX3CRV",
             "LUSD3CRV",
         ];
         (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
-        balances = (_b = {},
-            _b[token_1.tokenDataByNetwork.Mainnet["1INCH"]] = 100,
-            _b[token_1.tokenDataByNetwork.Mainnet["3Crv"]] = 200,
-            _b[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
-            _b[token_1.tokenDataByNetwork.Mainnet.yvCurve_FRAX] = 200,
-            _b[token_1.tokenDataByNetwork.Mainnet.yvCurve_stETH] = 200,
-            _b);
+        balances = {
+            [token_1.tokenDataByNetwork.Mainnet["1INCH"]]: 100,
+            [token_1.tokenDataByNetwork.Mainnet["3Crv"]]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.USDC]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.yvCurve_FRAX]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.yvCurve_stETH]: 200,
+        };
         expectedCurvePools = ["3Crv", "FRAX3CRV", "steCRV"];
         (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
-        balances = (_c = {},
-            _c[token_1.tokenDataByNetwork.Mainnet["1INCH"]] = 100,
-            _c[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
-            _c[token_1.tokenDataByNetwork.Mainnet.cvx3Crv] = 200,
-            _c[token_1.tokenDataByNetwork.Mainnet.cvxFRAX3CRV] = 200,
-            _c);
+        balances = {
+            [token_1.tokenDataByNetwork.Mainnet["1INCH"]]: 100,
+            [token_1.tokenDataByNetwork.Mainnet.USDC]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.cvx3Crv]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.cvxFRAX3CRV]: 200,
+        };
         expectedCurvePools = ["3Crv", "FRAX3CRV"];
         (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
-        balances = (_d = {},
-            _d[token_1.tokenDataByNetwork.Mainnet.wstETH] = 100,
-            _d[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
-            _d[token_1.tokenDataByNetwork.Mainnet.stkcvx3Crv] = 200,
-            _d[token_1.tokenDataByNetwork.Mainnet.stkcvxFRAX3CRV] = 200,
-            _d);
+        balances = {
+            [token_1.tokenDataByNetwork.Mainnet.wstETH]: 100,
+            [token_1.tokenDataByNetwork.Mainnet.USDC]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.stkcvx3Crv]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.stkcvxFRAX3CRV]: 200,
+        };
         expectedCurvePools = ["3Crv", "FRAX3CRV"];
         (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
-        balances = (_e = {},
-            _e[token_1.tokenDataByNetwork.Mainnet["3Crv"]] = 100,
-            _e[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
-            _e[token_1.tokenDataByNetwork.Mainnet.stkcvx3Crv] = 200,
-            _e[token_1.tokenDataByNetwork.Mainnet.cvx3Crv] = 200,
-            _e[token_1.tokenDataByNetwork.Mainnet.yvCurve_stETH] = 200,
-            _e);
+        balances = {
+            [token_1.tokenDataByNetwork.Mainnet["3Crv"]]: 100,
+            [token_1.tokenDataByNetwork.Mainnet.USDC]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.stkcvx3Crv]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.cvx3Crv]: 200,
+            [token_1.tokenDataByNetwork.Mainnet.yvCurve_stETH]: 200,
+        };
         expectedCurvePools = ["3Crv", "steCRV"];
         (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
     });
-    it("detectNetwork works correctly", function () {
+    it("detectNetwork works correctly", () => {
         (0, chai_1.expect)(pathOptions_1.PathOptionFactory.detectNetwork(token_1.tokenDataByNetwork.Mainnet["1INCH"])).to.be.eq("Mainnet");
     });
 });

package/lib/pathfinder/pathfinder.d.ts

@@ -6,9 +6,9 @@ import { SupportedToken } from "../tokens/token";
 import { IRouter } from "../types/@gearbox-protocol/router/contracts/interfaces/IRouter";
 import { MultiCall, PathFinderCloseResult, PathFinderOpenStrategyResult, PathFinderResult, SwapOperation } from "./core";
 export interface CloseResult {
-    amount: BigNumberish;
+    amount: bigint;
     calls: Array<MultiCall>;
-    gasUsage: BigNumberish;
+    gasUsage: bigint;
 }
 export declare class PathFinder {
     pathFinder: IRouter;
@@ -40,5 +40,5 @@ export declare class PathFinder {
      *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
      */
     findBestClosePath(creditAccount: CreditAccountData, slippage: number, noConcurency?: boolean): Promise<PathFinderCloseResult>;
-    static compare(r1: CloseResult, r2: CloseResult, gasPriceRAY: BigNumberish): CloseResult;
+    static compare(r1: CloseResult, r2: CloseResult, gasPriceRAY: bigint): CloseResult;
 }

package/lib/pathfinder/pathfinder.js

@@ -1,114 +1,63 @@
 "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.PathFinder = void 0;
-var ethers_1 = require("ethers");
-var constants_1 = require("../core/constants");
-var token_1 = require("../tokens/token");
-var types_1 = require("../types");
-var pathOptions_1 = require("./pathOptions");
-var MAX_GAS_PER_ROUTE = 200e6;
-var GAS_PER_BLOCK = 400e6;
-var PathFinder = /** @class */ (function () {
-    function PathFinder(address, provider, network, connectors) {
-        if (network === void 0) { network = "Mainnet"; }
-        var _this = this;
+const constants_1 = require("../core/constants");
+const token_1 = require("../tokens/token");
+const types_1 = require("../types");
+const formatter_1 = require("../utils/formatter");
+const pathOptions_1 = require("./pathOptions");
+const MAX_GAS_PER_ROUTE = 200e6;
+const GAS_PER_BLOCK = 400e6;
+class PathFinder {
+    pathFinder;
+    network;
+    static connectors = ["USDC", "WETH", "DAI"];
+    _connectors;
+    constructor(address, provider, network = "Mainnet", connectors) {
         this.pathFinder = types_1.IRouter__factory.connect(address, provider);
         this.network = network;
-        this._connectors = (connectors || PathFinder.connectors).map(function (c) { return token_1.tokenDataByNetwork[_this.network][c]; });
+        this._connectors = (connectors || PathFinder.connectors).map(c => token_1.tokenDataByNetwork[this.network][c]);
     }
-    PathFinder.prototype.findAllSwaps = function (creditAccount, swapOperation, tokenIn, tokenOut, amount, slippage) {
-        return __awaiter(this, void 0, void 0, function () {
-            var swapTask, results, unique;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        swapTask = {
-                            swapOperation: swapOperation,
-                            creditAccount: creditAccount.addr,
-                            tokenIn: token_1.tokenDataByNetwork[this.network][tokenIn] || tokenIn,
-                            tokenOut: token_1.tokenDataByNetwork[this.network][tokenOut] ||
-                                tokenOut,
-                            connectors: this._connectors,
-                            amount: amount,
-                            slippage: slippage,
-                            externalSlippage: false,
-                        };
-                        return [4 /*yield*/, this.pathFinder.callStatic.findAllSwaps(swapTask, {
-                                gasLimit: GAS_PER_BLOCK,
-                            })];
-                    case 1:
-                        results = _a.sent();
-                        unique = {};
-                        results.forEach(function (r) {
-                            var key = "".concat(r.amount.toHexString()).concat(r.calls
-                                .map(function (c) { return "".concat(c.target.toLowerCase()).concat(c.callData); })
-                                .join("-"));
-                            unique[key] = {
-                                amount: ethers_1.BigNumber.from(r.amount),
-                                calls: r.calls,
-                            };
-                        });
-                        return [2 /*return*/, Object.values(unique)];
-                }
-            });
+    async findAllSwaps(creditAccount, swapOperation, tokenIn, tokenOut, amount, slippage) {
+        const swapTask = {
+            swapOperation: swapOperation,
+            creditAccount: creditAccount.addr,
+            tokenIn: token_1.tokenDataByNetwork[this.network][tokenIn] || tokenIn,
+            tokenOut: token_1.tokenDataByNetwork[this.network][tokenOut] ||
+                tokenOut,
+            connectors: this._connectors,
+            amount: amount,
+            slippage,
+            externalSlippage: false,
+        };
+        const results = await this.pathFinder.callStatic.findAllSwaps(swapTask, {
+            gasLimit: GAS_PER_BLOCK,
         });
-    };
-    PathFinder.prototype.findOneTokenPath = function (creditAccount, tokenIn, tokenOut, amount, slippage) {
-        return __awaiter(this, void 0, void 0, function () {
-            var tokenInAddr, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tokenInAddr = token_1.tokenDataByNetwork[this.network][tokenIn] || tokenIn;
-                        return [4 /*yield*/, this.pathFinder.callStatic.findOneTokenPath(tokenInAddr, amount, token_1.tokenDataByNetwork[this.network][tokenOut] || tokenOut, creditAccount.addr, this._connectors, slippage, {
-                                gasLimit: GAS_PER_BLOCK,
-                            })];
-                    case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, {
-                                amount: ethers_1.BigNumber.from(result.amount),
-                                calls: result.calls,
-                            }];
-                }
-            });
+        const unique = {};
+        results.forEach(r => {
+            const key = `${r.amount.toHexString()}${r.calls
+                .map(c => `${c.target.toLowerCase()}${c.callData}`)
+                .join("-")}`;
+            unique[key] = {
+                amount: (0, formatter_1.toBigInt)(r.amount),
+                calls: r.calls,
+            };
         });
-    };
+        return Object.values(unique);
+    }
+    async findOneTokenPath(creditAccount, tokenIn, tokenOut, amount, slippage) {
+        const tokenInAddr = token_1.tokenDataByNetwork[this.network][tokenIn] || tokenIn;
+        // if (creditAccount.balances[tokenInAddr.toLowerCase()].lt(amount)) {
+        //   throw new Error(`Not enough balance for token ${tokenIn}`);
+        // }
+        const result = await this.pathFinder.callStatic.findOneTokenPath(tokenInAddr, amount, token_1.tokenDataByNetwork[this.network][tokenOut] || tokenOut, creditAccount.addr, this._connectors, slippage, {
+            gasLimit: GAS_PER_BLOCK,
+        });
+        return {
+            amount: (0, formatter_1.toBigInt)(result.amount),
+            calls: result.calls,
+        };
+    }
     /**
      * @dev Finds the best path for opening credit account and converting all NORMAL tokens and LP token in the way to TARGET
      * @param cm CreditManagerData which represents credit manager you want to use to open credit account
@@ -120,41 +69,29 @@ var PathFinder = /** @class */ (function () {
      * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
      * @returns PathFinderOpenStrategyResult which
      */
-    PathFinder.prototype.findOpenStrategyPath = function (cm, expectedBalances, target, slippage) {
-        return __awaiter(this, void 0, void 0, function () {
-            var targetAddr, expectedBalancesAddr, balances, result, balancesAfter;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        targetAddr = token_1.tokenDataByNetwork[this.network][target] || target;
-                        expectedBalancesAddr = Object.entries(expectedBalances).reduce(function (acc, _a) {
-                            var token = _a[0], balance = _a[1];
-                            var tokenAddr = token_1.tokenDataByNetwork[_this.network][token] || token;
-                            acc[tokenAddr.toLowerCase()] = balance;
-                            return acc;
-                        }, {});
-                        balances = cm.collateralTokens.map(function (token) { return ({
-                            token: token,
-                            balance: expectedBalancesAddr[token] || 0,
-                        }); });
-                        return [4 /*yield*/, this.pathFinder.callStatic.findOpenStrategyPath(cm.address, balances, targetAddr, this._connectors, slippage, {
-                                gasLimit: GAS_PER_BLOCK,
-                            })];
-                    case 1:
-                        result = _a.sent();
-                        balancesAfter = result[0].reduce(function (acc, b) {
-                            acc[b.token.toLowerCase()] = ethers_1.BigNumber.from(b.balance);
-                            return acc;
-                        }, {});
-                        return [2 /*return*/, {
-                                balances: balancesAfter,
-                                calls: result[1].calls,
-                            }];
-                }
-            });
+    async findOpenStrategyPath(cm, expectedBalances, target, slippage) {
+        const targetAddr = token_1.tokenDataByNetwork[this.network][target] || target;
+        const expectedBalancesAddr = Object.entries(expectedBalances).reduce((acc, [token, balance]) => {
+            const tokenAddr = token_1.tokenDataByNetwork[this.network][token] || token;
+            acc[tokenAddr.toLowerCase()] = balance;
+            return acc;
+        }, {});
+        const balances = cm.collateralTokens.map(token => ({
+            token,
+            balance: expectedBalancesAddr[token] || 0,
+        }));
+        const result = await this.pathFinder.callStatic.findOpenStrategyPath(cm.address, balances, targetAddr, this._connectors, slippage, {
+            gasLimit: GAS_PER_BLOCK,
         });
-    };
+        const balancesAfter = result[0].reduce((acc, b) => {
+            acc[b.token.toLowerCase()] = (0, formatter_1.toBigInt)(b.balance);
+            return acc;
+        }, {});
+        return {
+            balances: balancesAfter,
+            calls: result[1].calls,
+        };
+    }
     /**
      * @dev Finds the path to swap / withdraw all assets from CreditAccount into underlying asset
      *   Can bu used for closing credit account and for liquidations as well.
@@ -164,71 +101,41 @@ var PathFinder = /** @class */ (function () {
      *          - underlyingBalance - total balance of underlying token
      *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
      */
-    PathFinder.prototype.findBestClosePath = function (creditAccount, slippage, noConcurency) {
-        if (noConcurency === void 0) { noConcurency = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var loopsPerTx, pathOptions, results, _i, pathOptions_2, po, _a, _b, requests, bestResult;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        loopsPerTx = Math.floor(GAS_PER_BLOCK / MAX_GAS_PER_ROUTE);
-                        pathOptions = pathOptions_1.PathOptionFactory.generatePathOptions(creditAccount.allBalances, loopsPerTx);
-                        results = [];
-                        if (!noConcurency) return [3 /*break*/, 5];
-                        _i = 0, pathOptions_2 = pathOptions;
-                        _c.label = 1;
-                    case 1:
-                        if (!(_i < pathOptions_2.length)) return [3 /*break*/, 4];
-                        po = pathOptions_2[_i];
-                        _b = (_a = results).push;
-                        return [4 /*yield*/, this.pathFinder.callStatic.findBestClosePath(creditAccount.addr, this._connectors, slippage, po, loopsPerTx, false, {
-                                gasLimit: GAS_PER_BLOCK,
-                            })];
-                    case 2:
-                        _b.apply(_a, [_c.sent()]);
-                        _c.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [3 /*break*/, 7];
-                    case 5:
-                        requests = pathOptions.map(function (po) {
-                            return _this.pathFinder.callStatic.findBestClosePath(creditAccount.addr, _this._connectors, slippage, po, loopsPerTx, false, {
-                                gasLimit: GAS_PER_BLOCK,
-                            });
-                        });
-                        return [4 /*yield*/, Promise.all(requests)];
-                    case 6:
-                        results = _c.sent();
-                        _c.label = 7;
-                    case 7:
-                        bestResult = results.reduce(function (best, _a) {
-                            var pathFinderResult = _a[0], gasPriceRAY = _a[1];
-                            return PathFinder.compare(best, pathFinderResult, gasPriceRAY);
-                        }, {
-                            amount: ethers_1.BigNumber.from(0),
-                            gasUsage: 0,
-                            calls: [],
-                        });
-                        return [2 /*return*/, {
-                                underlyingBalance: ethers_1.BigNumber.from(bestResult.amount).add(creditAccount.allBalances[creditAccount.underlyingToken.toLowerCase()]),
-                                calls: bestResult.calls,
-                            }];
-                }
-            });
+    async findBestClosePath(creditAccount, slippage, noConcurency = false) {
+        const loopsPerTx = Math.floor(GAS_PER_BLOCK / MAX_GAS_PER_ROUTE);
+        const pathOptions = pathOptions_1.PathOptionFactory.generatePathOptions(creditAccount.allBalances, loopsPerTx);
+        let results = [];
+        if (noConcurency) {
+            for (const po of pathOptions) {
+                results.push(await this.pathFinder.callStatic.findBestClosePath(creditAccount.addr, this._connectors, slippage, po, loopsPerTx, false, {
+                    gasLimit: GAS_PER_BLOCK,
+                }));
+            }
+        }
+        else {
+            const requests = pathOptions.map(po => this.pathFinder.callStatic.findBestClosePath(creditAccount.addr, this._connectors, slippage, po, loopsPerTx, false, {
+                gasLimit: GAS_PER_BLOCK,
+            }));
+            results = await Promise.all(requests);
+        }
+        const bestResult = results.reduce((best, [pathFinderResult, gasPriceRAY]) => PathFinder.compare(best, {
+            calls: pathFinderResult.calls,
+            amount: (0, formatter_1.toBigInt)(pathFinderResult.amount),
+            gasUsage: (0, formatter_1.toBigInt)(pathFinderResult.gasUsage),
+        }, (0, formatter_1.toBigInt)(gasPriceRAY)), {
+            amount: 0n,
+            gasUsage: 0n,
+            calls: [],
         });
-    };
-    PathFinder.compare = function (r1, r2, gasPriceRAY) {
-        var comparator = function (_a, gasPrice) {
-            var amount = _a.amount, gasUsage = _a.gasUsage;
-            return ethers_1.BigNumber.from(amount).sub(ethers_1.BigNumber.from(gasUsage).mul(gasPrice).div(constants_1.RAY));
+        return {
+            underlyingBalance: bestResult.amount +
+                creditAccount.allBalances[creditAccount.underlyingToken.toLowerCase()],
+            calls: bestResult.calls,
         };
-        return comparator(r1, gasPriceRAY).gt(comparator(r2, gasPriceRAY))
-            ? r1
-            : r2;
-    };
-    PathFinder.connectors = ["USDC", "WETH", "DAI"];
-    return PathFinder;
-}());
+    }
+    static compare(r1, r2, gasPriceRAY) {
+        const comparator = ({ amount, gasUsage }, gasPrice) => amount - (gasUsage * gasPrice) / constants_1.RAY;
+        return comparator(r1, gasPriceRAY) > comparator(r2, gasPriceRAY) ? r1 : r2;
+    }
+}
 exports.PathFinder = PathFinder;

package/lib/pathfinder/pathfinder.spec.js

@@ -1,23 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var constants_1 = require("../core/constants");
-var pathfinder_1 = require("./pathfinder");
-describe("PathFinder test", function () {
-    it("compare works correctly", function () {
-        var r1 = {
-            amount: 2000,
-            gasUsage: 1000,
+const chai_1 = require("chai");
+const constants_1 = require("../core/constants");
+const pathfinder_1 = require("./pathfinder");
+describe("PathFinder test", () => {
+    it("compare works correctly", () => {
+        const r1 = {
+            amount: 2000n,
+            gasUsage: 1000n,
             calls: [],
         };
-        var r2 = {
-            amount: 3000,
-            gasUsage: 2000,
+        const r2 = {
+            amount: 3000n,
+            gasUsage: 2000n,
             calls: [],
         };
-        var result = pathfinder_1.PathFinder.compare(r1, r2, constants_1.RAY);
+        let result = pathfinder_1.PathFinder.compare(r1, r2, constants_1.RAY);
         (0, chai_1.expect)(result).to.be.eql(r2);
-        result = pathfinder_1.PathFinder.compare(r1, r2, constants_1.RAY.mul(2));
+        result = pathfinder_1.PathFinder.compare(r1, r2, constants_1.RAY * 2n);
         (0, chai_1.expect)(result).to.be.eql(r1);
     });
 });