@curvefi/api 2.66.30 → 2.66.31

package/lib/router.js

@@ -7,21 +7,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import memoize from "memoizee";
 import { ethers } from "ethers";
-import { curve, OLD_CHAINS } from "./curve.js";
+import { OLD_CHAINS } from "./curve.js";
 import { _cutZeros, _get_price_impact, _get_small_x, _getCoinAddresses, _getCoinDecimals, _getUsdRate, BN, DIGas, ensureAllowance, ensureAllowanceEstimateGas, ETH_ADDRESS, fromBN, getGasPriceFromL1, getTxCostsUsd, hasAllowance, isEth, parseUnits, runWorker, smartNumber, toBN, } from "./utils.js";
 import { getPool } from "./pools/index.js";
 import { _getAmplificationCoefficientsFromApi } from "./pools/utils.js";
 import { L2Networks } from "./constants/L2Networks.js";
 import { routeFinderWorker, routeFinderWorkerCode } from "./route-finder.worker.js";
 import { routeGraphWorker, routeGraphWorkerCode } from "./route-graph.worker.js";
+import { memoizeMethod } from "./constants/utils";
 const MAX_STEPS = 5;
 const ROUTE_LENGTH = (MAX_STEPS * 2) + 1;
-const _getTVL = memoize((poolId) => __awaiter(void 0, void 0, void 0, function* () { return Number(yield (getPool(poolId)).stats.totalLiquidity()); }), {
-    promise: true,
-    maxAge: 5 * 60 * 1000, // 5m
-});
+function _getTVL(poolId) {
+    return __awaiter(this, void 0, void 0, function* () { return Number(yield getPool.call(this, poolId).stats.totalLiquidityMemoized()); });
+}
 function entriesToDictAsync(entries, mapper) {
     return __awaiter(this, void 0, void 0, function* () {
         const result = {};
@@ -34,24 +33,26 @@ function mapDict(dict, mapper) {
     Object.entries(dict).forEach(([key, value]) => result[key] = mapper(key, value));
     return result;
 }
-const _buildRouteGraph = memoize((chainId, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
-    const constants = curve.constants;
-    const allPools = Object.entries(curve.getPoolsData()).filter(([id]) => !["crveth", "y", "busd", "pax"].includes(id));
-    const amplificationCoefficientDict = yield _getAmplificationCoefficientsFromApi();
-    const poolTvlDict = yield entriesToDictAsync(allPools, _getTVL);
-    const input = { constants, chainId, isLiteChain, allPools, amplificationCoefficientDict, poolTvlDict };
-    return runWorker(routeGraphWorkerCode, routeGraphWorker, Object.assign({ type: 'createRouteGraph' }, input));
-}), {
-    promise: true,
-    maxAge: 5 * 60 * 1000, // 5m
-});
-const _findRoutes = (inputCoinAddress, outputCoinAddress) => __awaiter(void 0, void 0, void 0, function* () {
-    const routerGraph = yield _buildRouteGraph(curve.chainId, curve.isLiteChain); // It's important to pass chainId to not use cache from another network
-    // extract only the fields we need for the worker
-    const poolData = mapDict(curve.getPoolsData(), (_, { is_lending, wrapped_coin_addresses, underlying_coin_addresses, token_address }) => ({ is_lending, wrapped_coin_addresses, underlying_coin_addresses, token_address }));
-    const input = { inputCoinAddress, outputCoinAddress, routerGraph, poolData };
-    return runWorker(routeFinderWorkerCode, routeFinderWorker, Object.assign({ type: 'findRoutes' }, input));
-});
+function _buildRouteGraphImpl(chainId, isLiteChain) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const constants = this.constants;
+        const allPools = Object.entries(this.getPoolsData()).filter(([id]) => !["crveth", "y", "busd", "pax"].includes(id));
+        const amplificationCoefficientDict = yield _getAmplificationCoefficientsFromApi.call(this);
+        const poolTvlDict = yield entriesToDictAsync(allPools, _getTVL.bind(this));
+        const input = { constants, chainId, isLiteChain, allPools, amplificationCoefficientDict, poolTvlDict };
+        return runWorker(routeGraphWorkerCode, routeGraphWorker, Object.assign({ type: 'createRouteGraph' }, input));
+    });
+}
+function _findRoutes(inputCoinAddress, outputCoinAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const _buildRouteGraph = memoizeMethod(this, '_buildRouteGraph', _buildRouteGraphImpl);
+        const routerGraph = yield _buildRouteGraph.call(this, this.chainId, this.isLiteChain); // It's important to pass chainId to not use cache from another network
+        // extract only the fields we need for the worker
+        const poolData = mapDict(this.getPoolsData(), (_, { is_lending, wrapped_coin_addresses, underlying_coin_addresses, token_address }) => ({ is_lending, wrapped_coin_addresses, underlying_coin_addresses, token_address }));
+        const input = { inputCoinAddress, outputCoinAddress, routerGraph, poolData };
+        return runWorker(routeFinderWorkerCode, routeFinderWorker, Object.assign({ type: 'findRoutes' }, input));
+    });
+}
 const _getRouteKey = (route, inputCoinAddress, outputCoinAddress) => {
     const sortedCoins = [inputCoinAddress, outputCoinAddress].sort();
     let key = `${sortedCoins[0]}-->`;
@@ -61,8 +62,8 @@ const _getRouteKey = (route, inputCoinAddress, outputCoinAddress) => {
     key += sortedCoins[1];
     return key;
 };
-const _getExchangeArgs = (route) => {
-    if (OLD_CHAINS.includes(curve.chainId)) {
+function _getExchangeArgs(route) {
+    if (OLD_CHAINS.includes(this.chainId)) {
         let _route = [];
         if (route.length > 0)
             _route.push(route[0].inputCoinAddress);
@@ -81,13 +82,13 @@ const _getExchangeArgs = (route) => {
             _secondBasePools.push(routeStep.secondBasePool);
             _secondBaseTokens.push(routeStep.secondBaseToken);
         }
-        _route = _route.concat(Array(ROUTE_LENGTH - _route.length).fill(curve.constants.ZERO_ADDRESS));
+        _route = _route.concat(Array(ROUTE_LENGTH - _route.length).fill(this.constants.ZERO_ADDRESS));
         _swapParams = _swapParams.concat(Array(MAX_STEPS - _swapParams.length).fill([0, 0, 0, 0, 0]));
-        _pools = _pools.concat(Array(MAX_STEPS - _pools.length).fill(curve.constants.ZERO_ADDRESS));
-        _basePools = _basePools.concat(Array(MAX_STEPS - _basePools.length).fill(curve.constants.ZERO_ADDRESS));
-        _baseTokens = _baseTokens.concat(Array(MAX_STEPS - _baseTokens.length).fill(curve.constants.ZERO_ADDRESS));
-        _secondBasePools = _secondBasePools.concat(Array(MAX_STEPS - _secondBasePools.length).fill(curve.constants.ZERO_ADDRESS));
-        _secondBaseTokens = _secondBaseTokens.concat(Array(MAX_STEPS - _secondBaseTokens.length).fill(curve.constants.ZERO_ADDRESS));
+        _pools = _pools.concat(Array(MAX_STEPS - _pools.length).fill(this.constants.ZERO_ADDRESS));
+        _basePools = _basePools.concat(Array(MAX_STEPS - _basePools.length).fill(this.constants.ZERO_ADDRESS));
+        _baseTokens = _baseTokens.concat(Array(MAX_STEPS - _baseTokens.length).fill(this.constants.ZERO_ADDRESS));
+        _secondBasePools = _secondBasePools.concat(Array(MAX_STEPS - _secondBasePools.length).fill(this.constants.ZERO_ADDRESS));
+        _secondBaseTokens = _secondBaseTokens.concat(Array(MAX_STEPS - _secondBaseTokens.length).fill(this.constants.ZERO_ADDRESS));
         return { _route, _swapParams, _pools, _basePools, _baseTokens, _secondBasePools, _secondBaseTokens };
     }
     else { // RouterNgPoolsOnly
@@ -99,299 +100,334 @@ const _getExchangeArgs = (route) => {
             _route.push(routeStep.swapAddress, routeStep.outputCoinAddress);
             _swapParams.push(routeStep.swapParams.slice(0, 4));
         }
-        _route = _route.concat(Array(ROUTE_LENGTH - _route.length).fill(curve.constants.ZERO_ADDRESS));
+        _route = _route.concat(Array(ROUTE_LENGTH - _route.length).fill(this.constants.ZERO_ADDRESS));
         _swapParams = _swapParams.concat(Array(MAX_STEPS - _swapParams.length).fill([0, 0, 0, 0]));
         return { _route, _swapParams };
     }
-};
+}
 const _estimatedGasForDifferentRoutesCache = {};
-const _estimateGasForDifferentRoutes = (routes, inputCoinAddress, outputCoinAddress, _amount) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    inputCoinAddress = inputCoinAddress.toLowerCase();
-    outputCoinAddress = outputCoinAddress.toLowerCase();
-    const contract = curve.contracts[curve.constants.ALIASES.router].contract;
-    const gasPromises = [];
-    const value = isEth(inputCoinAddress) ? _amount : curve.parseUnits("0");
-    for (const route of routes) {
-        const routeKey = _getRouteKey(route, inputCoinAddress, outputCoinAddress);
-        let gasPromise;
-        const { _route, _swapParams, _pools } = _getExchangeArgs(route);
-        if ((((_a = _estimatedGasForDifferentRoutesCache[routeKey]) === null || _a === void 0 ? void 0 : _a.time) || 0) + 3600000 < Date.now()) {
-            if (_pools) {
-                gasPromise = contract.exchange.estimateGas(_route, _swapParams, _amount, 0, _pools, Object.assign(Object.assign({}, curve.constantOptions), { value }));
-            }
-            else {
-                gasPromise = contract.exchange.estimateGas(_route, _swapParams, _amount, 0, Object.assign(Object.assign({}, curve.constantOptions), { value }));
-            }
-        }
-        else {
-            gasPromise = Promise.resolve(_estimatedGasForDifferentRoutesCache[routeKey].gas);
-        }
-        gasPromises.push(gasPromise);
-    }
-    try {
-        const _gasAmounts = yield Promise.all(gasPromises);
-        routes.forEach((route, i) => {
+function _estimateGasForDifferentRoutes(routes, inputCoinAddress, outputCoinAddress, _amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        inputCoinAddress = inputCoinAddress.toLowerCase();
+        outputCoinAddress = outputCoinAddress.toLowerCase();
+        const contract = this.contracts[this.constants.ALIASES.router].contract;
+        const gasPromises = [];
+        const value = isEth(inputCoinAddress) ? _amount : this.parseUnits("0");
+        for (const route of routes) {
             const routeKey = _getRouteKey(route, inputCoinAddress, outputCoinAddress);
-            _estimatedGasForDifferentRoutesCache[routeKey] = { 'gas': _gasAmounts[i], 'time': Date.now() };
-        });
-        return _gasAmounts.map((_g) => smartNumber(_g));
-    }
-    catch (err) { // No allowance
-        return routes.map(() => 0);
-    }
-});
-const _getBestRoute = memoize((inputCoinAddress, outputCoinAddress, amount) => __awaiter(void 0, void 0, void 0, function* () {
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const _amount = parseUnits(amount, inputCoinDecimals);
-    if (_amount === curve.parseUnits("0"))
-        return [];
-    const routesRaw = (yield _findRoutes(inputCoinAddress, outputCoinAddress)).map((route) => ({ route, _output: curve.parseUnits("0"), outputUsd: 0, txCostUsd: 0 }));
-    const routes = [];
-    try {
-        const calls = [];
-        const multicallContract = curve.contracts[curve.constants.ALIASES.router].multicallContract;
-        for (const r of routesRaw) {
-            const { _route, _swapParams, _pools } = _getExchangeArgs(r.route);
-            if (_pools) {
-                calls.push(multicallContract.get_dy(_route, _swapParams, _amount, _pools));
+            let gasPromise;
+            const { _route, _swapParams, _pools } = _getExchangeArgs.call(this, route);
+            if ((((_a = _estimatedGasForDifferentRoutesCache[routeKey]) === null || _a === void 0 ? void 0 : _a.time) || 0) + 3600000 < Date.now()) {
+                if (_pools) {
+                    gasPromise = contract.exchange.estimateGas(_route, _swapParams, _amount, 0, _pools, Object.assign(Object.assign({}, this.constantOptions), { value }));
+                }
+                else {
+                    gasPromise = contract.exchange.estimateGas(_route, _swapParams, _amount, 0, Object.assign(Object.assign({}, this.constantOptions), { value }));
+                }
             }
             else {
-                calls.push(multicallContract.get_dy(_route, _swapParams, _amount));
+                gasPromise = Promise.resolve(_estimatedGasForDifferentRoutesCache[routeKey].gas);
             }
+            gasPromises.push(gasPromise);
         }
-        const _outputAmounts = yield curve.multicallProvider.all(calls);
-        for (let i = 0; i < _outputAmounts.length; i++) {
-            routesRaw[i]._output = _outputAmounts[i];
-            routes.push(routesRaw[i]);
+        try {
+            const _gasAmounts = yield Promise.all(gasPromises);
+            routes.forEach((route, i) => {
+                const routeKey = _getRouteKey(route, inputCoinAddress, outputCoinAddress);
+                _estimatedGasForDifferentRoutesCache[routeKey] = { 'gas': _gasAmounts[i], 'time': Date.now() };
+            });
+            return _gasAmounts.map((_g) => smartNumber(_g));
         }
-    }
-    catch (err) {
-        // const promises = [];
-        // const contract = curve.contracts[curve.constants.ALIASES.router].contract;
-        // for (const r of routesRaw) {
-        //     const { _route, _swapParams, _pools } = _getExchangeArgs(r.route);
-        //     promises.push(contract.get_dy(_route, _swapParams, _amount, _pools, curve.constantOptions));
-        // }
-        //
-        // const res = await Promise.allSettled(promises);
-        //
-        // for (let i = 0; i < res.length; i++) {
-        //     if (res[i].status === 'rejected') {
-        //         console.log(`Route ${(routesRaw[i].route.map((s) => s.poolId)).join(" --> ")} is unavailable`);
-        //         continue;
-        //     }
-        //     routesRaw[i]._output = (res[i] as PromiseFulfilledResult<bigint>).value;
-        //     routes.push(routesRaw[i]);
-        // }
-        const contract = curve.contracts[curve.constants.ALIASES.router].contract;
-        const _outputs = [];
-        for (const r of routesRaw) {
-            const { _route, _swapParams, _pools } = _getExchangeArgs(r.route);
-            try {
+        catch ( // No allowance
+        _b) { // No allowance
+            return routes.map(() => 0);
+        }
+    });
+}
+function _getBestRouteImpl(inputCoinAddress, outputCoinAddress, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals.call(this, inputCoinAddress, outputCoinAddress);
+        const _amount = parseUnits(amount, inputCoinDecimals);
+        if (_amount === this.parseUnits("0"))
+            return [];
+        const routesRaw = (yield _findRoutes.call(this, inputCoinAddress, outputCoinAddress)).map((route) => ({ route, _output: this.parseUnits("0"), outputUsd: 0, txCostUsd: 0 }));
+        const routes = [];
+        try {
+            const calls = [];
+            const multicallContract = this.contracts[this.constants.ALIASES.router].multicallContract;
+            for (const r of routesRaw) {
+                const { _route, _swapParams, _pools } = _getExchangeArgs.call(this, r.route);
                 if (_pools) {
-                    _outputs.push(yield contract.get_dy(_route, _swapParams, _amount, _pools, curve.constantOptions));
+                    calls.push(multicallContract.get_dy(_route, _swapParams, _amount, _pools));
                 }
                 else {
-                    _outputs.push(yield contract.get_dy(_route, _swapParams, _amount, curve.constantOptions));
+                    calls.push(multicallContract.get_dy(_route, _swapParams, _amount));
                 }
             }
-            catch (e) {
-                _outputs.push(curve.parseUnits('-1', 0));
+            const _outputAmounts = yield this.multicallProvider.all(calls);
+            for (let i = 0; i < _outputAmounts.length; i++) {
+                routesRaw[i]._output = _outputAmounts[i];
+                routes.push(routesRaw[i]);
             }
         }
-        for (let i = 0; i < _outputs.length; i++) {
-            if (_outputs[i] < 0) {
-                console.log(`Route ${(routesRaw[i].route.map((s) => s.poolId)).join(" --> ")} is unavailable`);
-                continue;
+        catch (_a) {
+            // const promises = [];
+            // const contract = this.contracts[this.constants.ALIASES.router].contract;
+            // for (const r of routesRaw) {
+            //     const { _route, _swapParams, _pools } = _getExchangeArgs(r.route);
+            //     promises.push(contract.get_dy(_route, _swapParams, _amount, _pools, this.constantOptions));
+            // }
+            //
+            // const res = await Promise.allSettled(promises);
+            //
+            // for (let i = 0; i < res.length; i++) {
+            //     if (res[i].status === 'rejected') {
+            //         console.log(`Route ${(routesRaw[i].route.map((s) => s.poolId)).join(" --> ")} is unavailable`);
+            //         continue;
+            //     }
+            //     routesRaw[i]._output = (res[i] as PromiseFulfilledResult<bigint>).value;
+            //     routes.push(routesRaw[i]);
+            // }
+            const contract = this.contracts[this.constants.ALIASES.router].contract;
+            const _outputs = [];
+            for (const r of routesRaw) {
+                const { _route, _swapParams, _pools } = _getExchangeArgs.call(this, r.route);
+                try {
+                    if (_pools) {
+                        _outputs.push(yield contract.get_dy(_route, _swapParams, _amount, _pools, this.constantOptions));
+                    }
+                    else {
+                        _outputs.push(yield contract.get_dy(_route, _swapParams, _amount, this.constantOptions));
+                    }
+                }
+                catch (_b) {
+                    _outputs.push(this.parseUnits('-1', 0));
+                }
+            }
+            for (let i = 0; i < _outputs.length; i++) {
+                if (_outputs[i] < 0) {
+                    console.log(`Route ${(routesRaw[i].route.map((s) => s.poolId)).join(" --> ")} is unavailable`);
+                    continue;
+                }
+                routesRaw[i]._output = _outputs[i];
+                routes.push(routesRaw[i]);
             }
-            routesRaw[i]._output = _outputs[i];
-            routes.push(routesRaw[i]);
         }
-    }
-    if (routes.length === 0)
-        return [];
-    if (routes.length === 1)
-        return routes[0].route;
-    const [gasAmounts, outputCoinUsdRate, gasData, ethUsdRate] = yield Promise.all([
-        _estimateGasForDifferentRoutes(routes.map((r) => r.route), inputCoinAddress, outputCoinAddress, _amount),
-        _getUsdRate(outputCoinAddress),
-        fetch("https://api.curve.finance/api/getGas").then((res) => res.json()),
-        _getUsdRate(ETH_ADDRESS),
-    ]);
-    const gasPrice = gasData.data.gas.standard;
-    const expectedAmounts = (routes).map((route) => Number(curve.formatUnits(route._output, outputCoinDecimals)));
-    const expectedAmountsUsd = expectedAmounts.map((a) => a * outputCoinUsdRate);
-    const L1GasPrice = L2Networks.includes(curve.chainId) ? yield getGasPriceFromL1() : 0;
-    const txCostsUsd = gasAmounts.map((a) => getTxCostsUsd(ethUsdRate, gasPrice, a, L1GasPrice));
-    routes.forEach((route, i) => {
-        route.outputUsd = expectedAmountsUsd[i];
-        route.txCostUsd = txCostsUsd[i];
+        if (routes.length === 0)
+            return [];
+        if (routes.length === 1)
+            return routes[0].route;
+        const [gasAmounts, outputCoinUsdRate, gasData, ethUsdRate] = yield Promise.all([
+            _estimateGasForDifferentRoutes.call(this, routes.map((r) => r.route), inputCoinAddress, outputCoinAddress, _amount),
+            _getUsdRate.call(this, outputCoinAddress),
+            fetch("https://api.curve.finance/api/getGas").then((res) => res.json()),
+            _getUsdRate.call(this, ETH_ADDRESS),
+        ]);
+        const gasPrice = gasData.data.gas.standard;
+        const expectedAmounts = (routes).map((route) => Number(this.formatUnits(route._output, outputCoinDecimals)));
+        const expectedAmountsUsd = expectedAmounts.map((a) => a * outputCoinUsdRate);
+        const L1GasPrice = L2Networks.includes(this.chainId) ? yield getGasPriceFromL1.call(this) : 0;
+        const txCostsUsd = gasAmounts.map((a) => getTxCostsUsd(ethUsdRate, gasPrice, a, L1GasPrice));
+        routes.forEach((route, i) => {
+            route.outputUsd = expectedAmountsUsd[i];
+            route.txCostUsd = txCostsUsd[i];
+        });
+        return routes.reduce((route1, route2) => {
+            const diff = (route1.outputUsd - route1.txCostUsd) - (route2.outputUsd - route2.txCostUsd);
+            if (diff > 0)
+                return route1;
+            if (diff === 0 && route1.route.length < route2.route.length)
+                return route1;
+            return route2;
+        }).route;
     });
-    return routes.reduce((route1, route2) => {
-        const diff = (route1.outputUsd - route1.txCostUsd) - (route2.outputUsd - route2.txCostUsd);
-        if (diff > 0)
-            return route1;
-        if (diff === 0 && route1.route.length < route2.route.length)
-            return route1;
-        return route2;
-    }).route;
-}), {
-    promise: true,
-    maxAge: 5 * 60 * 1000, // 5m
-});
-const _getOutputForRoute = memoize((route, _amount) => __awaiter(void 0, void 0, void 0, function* () {
-    const contract = curve.contracts[curve.constants.ALIASES.router].contract;
-    const { _route, _swapParams, _pools } = _getExchangeArgs(route);
-    if (_pools) {
-        return yield contract.get_dy(_route, _swapParams, _amount, _pools, curve.constantOptions);
-    }
-    else {
-        return yield contract.get_dy(_route, _swapParams, _amount, curve.constantOptions);
-    }
-}), {
-    promise: true,
-    maxAge: 15 * 1000, // 15s
-});
+}
+function _getBestRoute(inputCoinAddress, outputCoinAddress, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return memoizeMethod(this, '_getBestRoute', _getBestRouteImpl).call(this, inputCoinAddress, outputCoinAddress, amount);
+    });
+}
+function _getOutputForRouteImpl(route, _amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contract = this.contracts[this.constants.ALIASES.router].contract;
+        const { _route, _swapParams, _pools } = _getExchangeArgs.call(this, route);
+        if (_pools) {
+            return yield contract.get_dy(_route, _swapParams, _amount, _pools, this.constantOptions);
+        }
+        else {
+            return yield contract.get_dy(_route, _swapParams, _amount, this.constantOptions);
+        }
+    });
+}
+function _getOutputForRoute(route, _amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return memoizeMethod(this, '_getOutputForRoute', _getOutputForRouteImpl).call(this, route, _amount);
+    });
+}
 const _routesCache = {};
-const _getBestRouteAndOutput = (inputCoin, outputCoin, amount) => {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
+function _getBestRouteAndOutput(inputCoin, outputCoin, amount) {
+    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses.call(this, inputCoin, outputCoin);
     const key = `${inputCoinAddress}-${outputCoinAddress}-${amount}`;
     if (!(key in _routesCache))
         throw Error("You must call getBestRouteAndOutput first");
     return _routesCache[key];
-};
-export const getBestRouteAndOutput = (inputCoin, outputCoin, amount) => __awaiter(void 0, void 0, void 0, function* () {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const route = yield _getBestRoute(inputCoinAddress, outputCoinAddress, amount); // 5 minutes cache
-    if (route.length === 0)
-        return { route, output: '0.0' };
-    const _output = yield _getOutputForRoute(route, parseUnits(amount, inputCoinDecimals)); // 15 seconds cache, so we call it to get fresh output estimation
-    _routesCache[`${inputCoinAddress}-${outputCoinAddress}-${amount}`] = {
-        route,
-        output: curve.formatUnits(_output + BigInt(1), outputCoinDecimals),
-        timestamp: Date.now(),
-    };
-    return { route, output: curve.formatUnits(_output + BigInt(1), outputCoinDecimals) };
-});
-export const getArgs = (route) => _getExchangeArgs(route);
-export const swapExpected = (inputCoin, outputCoin, amount) => __awaiter(void 0, void 0, void 0, function* () { return (yield getBestRouteAndOutput(inputCoin, outputCoin, amount))['output']; });
-export const swapRequired = (inputCoin, outputCoin, outAmount) => __awaiter(void 0, void 0, void 0, function* () {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const _outAmount = parseUnits(outAmount, outputCoinDecimals);
-    const p1 = (yield _getUsdRate(inputCoinAddress)) || 1;
-    const p2 = (yield _getUsdRate(outputCoinAddress)) || 1;
-    const approximateRequiredAmount = Number(outAmount) * p2 / p1;
-    const route = yield _getBestRoute(inputCoinAddress, outputCoinAddress, approximateRequiredAmount);
-    const contract = curve.contracts[curve.constants.ALIASES.router].contract;
-    const { _route, _swapParams, _pools, _basePools, _baseTokens, _secondBasePools, _secondBaseTokens } = _getExchangeArgs(route);
-    let _required;
-    if ("get_dx(address[11],uint256[5][5],uint256,address[5],address[5],address[5],address[5],address[5])" in contract) {
-        _required = yield contract.get_dx(_route, _swapParams, _outAmount, _pools, _basePools, _baseTokens, _secondBasePools, _secondBaseTokens, curve.constantOptions);
-    }
-    else if (_pools) {
-        _required = yield contract.get_dx(_route, _swapParams, _outAmount, _pools, _basePools, _baseTokens, curve.constantOptions);
-    }
-    else {
-        _required = yield contract.get_dx(_route, _swapParams, _outAmount, curve.constantOptions);
-    }
-    return curve.formatUnits(_required, inputCoinDecimals);
-});
-export const swapPriceImpact = (inputCoin, outputCoin, amount) => __awaiter(void 0, void 0, void 0, function* () {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const { route, output } = _getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount);
-    const _amount = parseUnits(amount, inputCoinDecimals);
-    const _output = parseUnits(output, outputCoinDecimals);
-    const smallAmountIntBN = _get_small_x(_amount, _output, inputCoinDecimals, outputCoinDecimals);
-    const amountIntBN = toBN(_amount, 0);
-    if (smallAmountIntBN.gte(amountIntBN))
-        return 0;
-    const contract = curve.contracts[curve.constants.ALIASES.router].contract;
-    let _smallAmount = fromBN(smallAmountIntBN.div(Math.pow(10, inputCoinDecimals)), inputCoinDecimals);
-    const { _route, _swapParams, _pools } = _getExchangeArgs(route);
-    let _smallOutput;
-    try {
-        if (_pools) {
-            _smallOutput = yield contract.get_dy(_route, _swapParams, _smallAmount, _pools, curve.constantOptions);
+}
+export function getBestRouteAndOutput(inputCoin, outputCoin, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses.call(this, inputCoin, outputCoin);
+        const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals.call(this, inputCoinAddress, outputCoinAddress);
+        const route = yield _getBestRoute.call(this, inputCoinAddress, outputCoinAddress, amount); // 5 minutes cache
+        if (route.length === 0)
+            return { route, output: '0.0' };
+        const _output = yield _getOutputForRoute.call(this, route, parseUnits(amount, inputCoinDecimals)); // 15 seconds cache, so we call it to get fresh output estimation
+        _routesCache[`${inputCoinAddress}-${outputCoinAddress}-${amount}`] = {
+            route,
+            output: this.formatUnits(_output + BigInt(1), outputCoinDecimals),
+            timestamp: Date.now(),
+        };
+        return { route, output: this.formatUnits(_output + BigInt(1), outputCoinDecimals) };
+    });
+}
+export function getArgs(route) {
+    return _getExchangeArgs.call(this, route);
+}
+export function swapExpected(inputCoin, outputCoin, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield getBestRouteAndOutput.call(this, inputCoin, outputCoin, amount))['output'];
+    });
+}
+export function swapRequired(inputCoin, outputCoin, outAmount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses.call(this, inputCoin, outputCoin);
+        const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals.call(this, inputCoinAddress, outputCoinAddress);
+        const _outAmount = parseUnits(outAmount, outputCoinDecimals);
+        const p1 = (yield _getUsdRate.call(this, inputCoinAddress)) || 1;
+        const p2 = (yield _getUsdRate.call(this, outputCoinAddress)) || 1;
+        const approximateRequiredAmount = Number(outAmount) * p2 / p1;
+        const route = yield _getBestRoute.call(this, inputCoinAddress, outputCoinAddress, approximateRequiredAmount);
+        const contract = this.contracts[this.constants.ALIASES.router].contract;
+        const { _route, _swapParams, _pools, _basePools, _baseTokens, _secondBasePools, _secondBaseTokens } = _getExchangeArgs.call(this, route);
+        let _required;
+        if ("get_dx(address[11],uint256[5][5],uint256,address[5],address[5],address[5],address[5],address[5])" in contract) {
+            _required = yield contract.get_dx(_route, _swapParams, _outAmount, _pools, _basePools, _baseTokens, _secondBasePools, _secondBaseTokens, this.constantOptions);
+        }
+        else if (_pools) {
+            _required = yield contract.get_dx(_route, _swapParams, _outAmount, _pools, _basePools, _baseTokens, this.constantOptions);
         }
         else {
-            _smallOutput = yield contract.get_dy(_route, _swapParams, _smallAmount, curve.constantOptions);
+            _required = yield contract.get_dx(_route, _swapParams, _outAmount, this.constantOptions);
         }
-    }
-    catch (e) {
-        _smallAmount = curve.parseUnits("1", inputCoinDecimals); // Dirty hack
+        return this.formatUnits(_required, inputCoinDecimals);
+    });
+}
+export function swapPriceImpact(inputCoin, outputCoin, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses.call(this, inputCoin, outputCoin);
+        const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals.call(this, inputCoinAddress, outputCoinAddress);
+        const { route, output } = _getBestRouteAndOutput.call(this, inputCoinAddress, outputCoinAddress, amount);
+        const _amount = parseUnits(amount, inputCoinDecimals);
+        const _output = parseUnits(output, outputCoinDecimals);
+        const smallAmountIntBN = _get_small_x(_amount, _output, inputCoinDecimals, outputCoinDecimals);
+        const amountIntBN = toBN(_amount, 0);
+        if (smallAmountIntBN.gte(amountIntBN))
+            return 0;
+        const contract = this.contracts[this.constants.ALIASES.router].contract;
+        let _smallAmount = fromBN(smallAmountIntBN.div(Math.pow(10, inputCoinDecimals)), inputCoinDecimals);
+        const { _route, _swapParams, _pools } = _getExchangeArgs.call(this, route);
+        let _smallOutput;
+        try {
+            if (_pools) {
+                _smallOutput = yield contract.get_dy(_route, _swapParams, _smallAmount, _pools, this.constantOptions);
+            }
+            else {
+                _smallOutput = yield contract.get_dy(_route, _swapParams, _smallAmount, this.constantOptions);
+            }
+        }
+        catch (_a) {
+            _smallAmount = this.parseUnits("1", inputCoinDecimals); // Dirty hack
+            if (_pools) {
+                _smallOutput = yield contract.get_dy(_route, _swapParams, _smallAmount, _pools, this.constantOptions);
+            }
+            else {
+                _smallOutput = yield contract.get_dy(_route, _swapParams, _smallAmount, this.constantOptions);
+            }
+        }
+        const priceImpactBN = _get_price_impact(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
+        return Number(_cutZeros(priceImpactBN.toFixed(4)));
+    });
+}
+export function swapIsApproved(inputCoin, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield hasAllowance.call(this, [inputCoin], [amount], this.signerAddress, this.constants.ALIASES.router);
+    });
+}
+export function swapApproveEstimateGas(inputCoin, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield ensureAllowanceEstimateGas.call(this, [inputCoin], [amount], this.constants.ALIASES.router);
+    });
+}
+export function swapApprove(inputCoin, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield ensureAllowance.call(this, [inputCoin], [amount], this.constants.ALIASES.router);
+    });
+}
+export function swapEstimateGas(inputCoin, outputCoin, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses.call(this, inputCoin, outputCoin);
+        const [inputCoinDecimals] = _getCoinDecimals.call(this, inputCoinAddress, outputCoinAddress);
+        const { route } = _getBestRouteAndOutput.call(this, inputCoinAddress, outputCoinAddress, amount);
+        if (route.length === 0)
+            return 0;
+        const _amount = parseUnits(amount, inputCoinDecimals);
+        const [gas] = yield _estimateGasForDifferentRoutes.call(this, [route], inputCoinAddress, outputCoinAddress, _amount);
+        return gas;
+    });
+}
+export function swap(inputCoin_1, outputCoin_1, amount_1) {
+    return __awaiter(this, arguments, void 0, function* (inputCoin, outputCoin, amount, slippage = 0.5) {
+        const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses.call(this, inputCoin, outputCoin);
+        const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals.call(this, inputCoinAddress, outputCoinAddress);
+        yield swapApprove.call(this, inputCoin, amount);
+        const { route, output } = _getBestRouteAndOutput.call(this, inputCoinAddress, outputCoinAddress, amount);
+        if (route.length === 0) {
+            throw new Error("This pair can't be exchanged");
+        }
+        const { _route, _swapParams, _pools } = _getExchangeArgs.call(this, route);
+        const _amount = parseUnits(amount, inputCoinDecimals);
+        const minRecvAmountBN = BN(output).times(100 - slippage).div(100);
+        const _minRecvAmount = fromBN(minRecvAmountBN, outputCoinDecimals);
+        const contract = this.contracts[this.constants.ALIASES.router].contract;
+        const value = isEth(inputCoinAddress) ? _amount : this.parseUnits("0");
+        yield this.updateFeeData();
         if (_pools) {
-            _smallOutput = yield contract.get_dy(_route, _swapParams, _smallAmount, _pools, curve.constantOptions);
+            const gasLimit = (DIGas(yield contract.exchange.estimateGas(_route, _swapParams, _amount, _minRecvAmount, _pools, Object.assign(Object.assign({}, this.constantOptions), { value })))) * (this.chainId === 1 ? this.parseUnits("130", 0) : this.parseUnits("160", 0)) / this.parseUnits("100", 0);
+            return yield contract.exchange(_route, _swapParams, _amount, _minRecvAmount, _pools, Object.assign(Object.assign({}, this.options), { value, gasLimit }));
         }
         else {
-            _smallOutput = yield contract.get_dy(_route, _swapParams, _smallAmount, curve.constantOptions);
+            const gasLimit = (DIGas(yield contract.exchange.estimateGas(_route, _swapParams, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.constantOptions), { value })))) * this.parseUnits("160", 0) / this.parseUnits("100", 0);
+            return yield contract.exchange(_route, _swapParams, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.options), { value, gasLimit }));
         }
-    }
-    const priceImpactBN = _get_price_impact(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
-    return Number(_cutZeros(priceImpactBN.toFixed(4)));
-});
-export const swapIsApproved = (inputCoin, amount) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield hasAllowance([inputCoin], [amount], curve.signerAddress, curve.constants.ALIASES.router);
-});
-export const swapApproveEstimateGas = (inputCoin, amount) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield ensureAllowanceEstimateGas([inputCoin], [amount], curve.constants.ALIASES.router);
-});
-export const swapApprove = (inputCoin, amount) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield ensureAllowance([inputCoin], [amount], curve.constants.ALIASES.router);
-});
-export const swapEstimateGas = (inputCoin, outputCoin, amount) => __awaiter(void 0, void 0, void 0, function* () {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const { route } = _getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount);
-    if (route.length === 0)
-        return 0;
-    const _amount = parseUnits(amount, inputCoinDecimals);
-    const [gas] = yield _estimateGasForDifferentRoutes([route], inputCoinAddress, outputCoinAddress, _amount);
-    return gas;
-});
-export const swap = (inputCoin_1, outputCoin_1, amount_1, ...args_1) => __awaiter(void 0, [inputCoin_1, outputCoin_1, amount_1, ...args_1], void 0, function* (inputCoin, outputCoin, amount, slippage = 0.5) {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    yield swapApprove(inputCoin, amount);
-    const { route, output } = _getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount);
-    if (route.length === 0) {
-        throw new Error("This pair can't be exchanged");
-    }
-    const { _route, _swapParams, _pools } = _getExchangeArgs(route);
-    const _amount = parseUnits(amount, inputCoinDecimals);
-    const minRecvAmountBN = BN(output).times(100 - slippage).div(100);
-    const _minRecvAmount = fromBN(minRecvAmountBN, outputCoinDecimals);
-    const contract = curve.contracts[curve.constants.ALIASES.router].contract;
-    const value = isEth(inputCoinAddress) ? _amount : curve.parseUnits("0");
-    yield curve.updateFeeData();
-    if (_pools) {
-        const gasLimit = (DIGas(yield contract.exchange.estimateGas(_route, _swapParams, _amount, _minRecvAmount, _pools, Object.assign(Object.assign({}, curve.constantOptions), { value })))) * (curve.chainId === 1 ? curve.parseUnits("130", 0) : curve.parseUnits("160", 0)) / curve.parseUnits("100", 0);
-        return yield contract.exchange(_route, _swapParams, _amount, _minRecvAmount, _pools, Object.assign(Object.assign({}, curve.options), { value, gasLimit }));
-    }
-    else {
-        const gasLimit = (DIGas(yield contract.exchange.estimateGas(_route, _swapParams, _amount, _minRecvAmount, Object.assign(Object.assign({}, curve.constantOptions), { value })))) * curve.parseUnits("160", 0) / curve.parseUnits("100", 0);
-        return yield contract.exchange(_route, _swapParams, _amount, _minRecvAmount, Object.assign(Object.assign({}, curve.options), { value, gasLimit }));
-    }
-});
-export const getSwappedAmount = (tx, outputCoin) => __awaiter(void 0, void 0, void 0, function* () {
-    const [outputCoinAddress] = _getCoinAddresses(outputCoin);
-    const [outputCoinDecimals] = _getCoinDecimals(outputCoinAddress);
-    const txInfo = yield tx.wait();
-    if (txInfo === null)
-        return '0.0';
-    let res;
-    for (let i = 1; i <= txInfo.logs.length; i++) {
-        try {
-            const abiCoder = ethers.AbiCoder.defaultAbiCoder();
-            res = abiCoder.decode([`address[${ROUTE_LENGTH}]`, `uint256[${MAX_STEPS}][${MAX_STEPS}]`, `address[${MAX_STEPS}]`, 'uint256', 'uint256'], ethers.dataSlice(txInfo.logs[txInfo.logs.length - i].data, 0));
-            break;
+    });
+}
+export function getSwappedAmount(tx, outputCoin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [outputCoinAddress] = _getCoinAddresses.call(this, outputCoin);
+        const [outputCoinDecimals] = _getCoinDecimals.call(this, outputCoinAddress);
+        const txInfo = yield tx.wait();
+        if (txInfo === null)
+            return '0.0';
+        let res;
+        for (let i = 1; i <= txInfo.logs.length; i++) {
+            try {
+                const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+                res = abiCoder.decode([`address[${ROUTE_LENGTH}]`, `uint256[${MAX_STEPS}][${MAX_STEPS}]`, `address[${MAX_STEPS}]`, 'uint256', 'uint256'], ethers.dataSlice(txInfo.logs[txInfo.logs.length - i].data, 0));
+                break;
+            }
+            catch (_a) { }
         }
-        catch (err) { }
-    }
-    if (res === undefined)
-        return '0.0';
-    return curve.formatUnits(res[res.length - 1], outputCoinDecimals);
-});
+        if (res === undefined)
+            return '0.0';
+        return this.formatUnits(res[res.length - 1], outputCoinDecimals);
+    });
+}