@gearbox-protocol/sdk 0.0.100 → 0.0.103

package/lib/pathfinder/convexLP.js

@@ -38,40 +38,37 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConvexLPPathFinder = void 0;
 var convex_1 = require("../tokens/convex");
+var mappers_1 = require("../utils/mappers");
 var ConvexLPPathFinder = /** @class */ (function () {
     function ConvexLPPathFinder() {
     }
+    // eslint-disable-next-line class-methods-use-this
     ConvexLPPathFinder.prototype.findWithdrawPaths = function (p) {
         return __awaiter(this, void 0, void 0, function () {
-            var pids, _i, _a, _b, cvxToken, tokenData, currentBalance;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        pids = new Set();
-                        for (_i = 0, _a = Object.entries(convex_1.convexTokens); _i < _a.length; _i++) {
-                            _b = _a[_i], cvxToken = _b[0], tokenData = _b[1];
-                            currentBalance = p.popBalance(cvxToken);
-                            if (currentBalance.gt(1)) {
-                                pids.add(tokenData.pid);
-                            }
-                        }
-                        return [4 /*yield*/, p.withdrawTokens()];
-                    case 1: 
-                    // const convexPathFinder = ConvexPathFinder__factory.connect(
-                    //     pathFindersByNetwork[p.networkType].CONVEX_PATH_FINDER,
-                    //     p.provider
-                    // );
-                    // const tokenBalances = await convexPathFinder.calcRewards(
-                    //     p.creditAccount.addr,
-                    //     Array.from(pids)
-                    // );
-                    // for (let balance of tokenBalances) {
-                    //     p.balances[balance.token] = p.balances[balance.token].add(
-                    //         balance.balance
-                    //     );
-                    // }
-                    return [2 /*return*/, _c.sent()];
-                }
+            var pids;
+            return __generator(this, function (_a) {
+                pids = (0, mappers_1.objectEntries)(convex_1.convexTokens).reduce(function (acc, _a) {
+                    var cvxToken = _a[0], tokenData = _a[1];
+                    var currentBalance = p.popBalance(cvxToken);
+                    if (currentBalance.gt(1)) {
+                        pids.add(tokenData.pid);
+                    }
+                    return acc;
+                }, new Set());
+                // const convexPathFinder = ConvexPathFinder__factory.connect(
+                //     pathFindersByNetwork[p.networkType].CONVEX_PATH_FINDER,
+                //     p.provider
+                // );
+                // const tokenBalances = await convexPathFinder.calcRewards(
+                //     p.creditAccount.addr,
+                //     Array.from(pids)
+                // );
+                // for (let balance of tokenBalances) {
+                //     p.balances[balance.token] = p.balances[balance.token].add(
+                //         balance.balance
+                //     );
+                // }
+                return [2 /*return*/, p.withdrawTokens()];
             });
         });
     };

package/lib/pathfinder/curveLP.d.ts

@@ -1,4 +1,4 @@
-import { LPWithdrawPathFinder, Path } from "./path";
+import type { LPWithdrawPathFinder, Path } from "./path";
 import { CurveLPToken } from "../tokens/curveLP";
 import { CurvePoolContract } from "../contracts/contracts";
 export declare class CurvePathFinder implements LPWithdrawPathFinder {

package/lib/pathfinder/curveLP.js

@@ -45,12 +45,11 @@ var types_1 = require("../types");
 var CurvePathFinder = /** @class */ (function () {
     function CurvePathFinder(token) {
         this.lpToken = token;
-        var curvePools = curveLP_1.curveTokens[this.lpToken].lpActions.filter(function (a) { return a.type == tradeTypes_1.TradeType.CurveWithdrawLP; });
+        var curvePools = curveLP_1.curveTokens[this.lpToken].lpActions.filter(function (a) { return a.type === tradeTypes_1.TradeType.CurveWithdrawLP; });
         if (curvePools.length !== 1)
             throw new Error("Cant find Withdrawer");
         this.contract = curvePools[0].contract;
-        var wrapper = contracts_1.contractParams[curvePools[0].contract]
-            .wrapper;
+        var wrapper = contracts_1.contractParams[curvePools[0].contract].wrapper;
         if (wrapper) {
             this.contract = wrapper;
         }
@@ -66,9 +65,8 @@ var CurvePathFinder = /** @class */ (function () {
                         lpBalance = p.popBalance(this.lpToken);
                         multiCallContract = new multicall_1.MultiCallContract(contracts_1.contractsByAddress[this.contract], types_1.ICurvePool__factory.createInterface(), p.provider);
                         data = [];
-                        for (i = 0; i < nCoins; i++) {
+                        for (i = 0; i < nCoins; i += 1) {
                             data.push({
-                                // @ts-ignore
                                 method: "calc_withdraw_one_coin(uint256,int128)",
                                 params: [lpBalance, i]
                             });
@@ -76,9 +74,9 @@ var CurvePathFinder = /** @class */ (function () {
                         return [4 /*yield*/, multiCallContract.call(data)];
                     case 1:
                         balances = _a.sent();
-                        console.log(balances);
+                        console.debug(balances);
                         paths = [];
-                        for (i = 0; i < nCoins; i++) {
+                        for (i = 0; i < nCoins; i += 1) {
                             newPath = p.clone();
                             // newPath.balances[coins[i]] = newPath.balances[coins[i]].add(balances[i]);
                             // newPath.calls.push({

package/lib/pathfinder/path.d.ts

@@ -24,7 +24,7 @@ export declare class Path {
         totalGasLimit: number;
     });
     popBalance(token: SupportedToken): BigNumber;
-    private comparedByPriority;
+    private static comparedByPriority;
     static findBestPath(creditAccount: CreditAccountData, creditManager: CreditManagerData, provider: ethers.providers.Provider): Promise<void>;
     withdrawTokens(): Promise<Array<Path>>;
     clone(): Path;

package/lib/pathfinder/path.js

@@ -76,15 +76,15 @@ var Path = /** @class */ (function () {
         this.balances[token] = ethers_1.BigNumber.from(1);
         return currentBalance.sub(1);
     };
-    Path.prototype.comparedByPriority = function (_a, _b) {
-        var tokenA = _a[0], _balanceA = _a[1];
-        var tokenB = _b[0], _balanceB = _b[1];
+    Path.comparedByPriority = function (_a, _b) {
+        var tokenA = _a[0];
+        var tokenB = _b[0];
         var priorityTokenA = priority_1.priority[token_1.supportedTokens[tokenA].type];
         var priorityTokenB = priority_1.priority[token_1.supportedTokens[tokenB].type];
         if (priorityTokenA > priorityTokenB) {
             return -1;
         }
-        else if (priorityTokenA < priorityTokenB) {
+        if (priorityTokenA < priorityTokenB) {
             return 1;
         }
         return 0;
@@ -123,8 +123,8 @@ var Path = /** @class */ (function () {
                     case 2:
                         lpPaths = _a.sent();
                         pathFinder = types_1.PathFinder__factory.connect(contracts_1.pathFindersByNetwork[networkType].PATH_FINDER, provider);
-                        console.log(lpPaths);
-                        console.log(pathFinder);
+                        console.debug(lpPaths);
+                        console.debug(pathFinder);
                         return [2 /*return*/];
                 }
             });
@@ -134,43 +134,39 @@ var Path = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             var existingTokens, nextToken, lpPathFinder;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        existingTokens = Object.entries(this.balances)
-                            .filter(function (_a) {
-                            var _token = _a[0], balance = _a[1];
-                            return balance.gt(1);
-                        })
-                            .sort(this.comparedByPriority);
-                        // TODO: Add checks for lenght
-                        if (existingTokens.length === 0)
-                            throw new Error("No tokens with balance >1");
-                        nextToken = existingTokens.at(0)[0];
-                        // Get balances and keep non-zero only
-                        // Find token with highest priority
-                        // Get token type of this token
-                        switch (token_1.supportedTokens[nextToken].type) {
-                            case tokenType_1.TokenType.NORMAL_TOKEN:
-                            case tokenType_1.TokenType.CONNECTOR:
-                                return [2 /*return*/, [this]];
-                            case tokenType_1.TokenType.YEARN_VAULT_OF_CURVE_LP:
-                            case tokenType_1.TokenType.YEARN_VAULT_OF_META_CURVE_LP:
-                            case tokenType_1.TokenType.YEARN_VAULT:
-                                lpPathFinder = new yVault_1.YearnVaultPathFinder(nextToken);
-                                break;
-                            case tokenType_1.TokenType.CONVEX_LP_TOKEN:
-                                lpPathFinder = new convexLP_1.ConvexLPPathFinder();
-                                break;
-                            case tokenType_1.TokenType.META_CURVE_LP:
-                            case tokenType_1.TokenType.CURVE_LP:
-                                lpPathFinder = new curveLP_1.CurvePathFinder(nextToken);
-                                break;
-                            default:
-                                throw new Error("Token type not supported yet");
-                        }
-                        return [4 /*yield*/, lpPathFinder.findWithdrawPaths(this)];
-                    case 1: return [2 /*return*/, _a.sent()];
+                existingTokens = Object.entries(this.balances)
+                    .filter(function (_a) {
+                    var balance = _a[1];
+                    return balance.gt(1);
+                })
+                    .sort(Path.comparedByPriority);
+                // TODO: Add checks for lenght
+                if (existingTokens.length === 0)
+                    throw new Error("No tokens with balance >1");
+                nextToken = existingTokens[0][0];
+                // Get balances and keep non-zero only
+                // Find token with highest priority
+                // Get token type of this token
+                switch (token_1.supportedTokens[nextToken].type) {
+                    case tokenType_1.TokenType.NORMAL_TOKEN:
+                    case tokenType_1.TokenType.CONNECTOR:
+                        return [2 /*return*/, [this]];
+                    case tokenType_1.TokenType.YEARN_VAULT_OF_CURVE_LP:
+                    case tokenType_1.TokenType.YEARN_VAULT_OF_META_CURVE_LP:
+                    case tokenType_1.TokenType.YEARN_VAULT:
+                        lpPathFinder = new yVault_1.YearnVaultPathFinder(nextToken);
+                        break;
+                    case tokenType_1.TokenType.CONVEX_LP_TOKEN:
+                        lpPathFinder = new convexLP_1.ConvexLPPathFinder();
+                        break;
+                    case tokenType_1.TokenType.META_CURVE_LP:
+                    case tokenType_1.TokenType.CURVE_LP:
+                        lpPathFinder = new curveLP_1.CurvePathFinder(nextToken);
+                        break;
+                    default:
+                        throw new Error("Token type not supported yet");
                 }
+                return [2 /*return*/, lpPathFinder.findWithdrawPaths(this)];
             });
         });
     };

package/lib/pathfinder/trade.d.ts

@@ -1,5 +1,4 @@
-import { BigNumber } from "ethers";
-import { BytesLike } from "@ethersproject/bytes";
+import { BigNumber, BytesLike } from "ethers";
 import { SwapType } from "./tradeTypes";
 export interface CloseTradePath {
     path: Array<string>;

package/lib/pathfinder/tradeTypes.d.ts

@@ -1,8 +1,8 @@
-import { ConvexPoolContract, CurvePoolContract, UniswapV2Contract, YearnVaultContract } from "../contracts/contracts";
-import { NormalToken } from "../tokens/normal";
-import { CurveLPToken } from "../tokens/curveLP";
-import { YearnLPToken } from "../tokens/yearn";
-import { ConvexLPToken, ConvexStakedPhantomToken } from "../tokens/convex";
+import type { ConvexPoolContract, CurvePoolContract, UniswapV2Contract, YearnVaultContract } from "../contracts/contracts";
+import type { NormalToken } from "../tokens/normal";
+import type { CurveLPToken } from "../tokens/curveLP";
+import type { YearnLPToken } from "../tokens/yearn";
+import type { ConvexLPToken, ConvexStakedPhantomToken } from "../tokens/convex";
 export declare enum TradeType {
     UniswapV2Swap = 0,
     UniswapV3Swap = 1,

package/lib/pathfinder/yVault.d.ts

@@ -1,10 +1,10 @@
-import { Path, LPWithdrawPathFinder } from "./path";
 import { YearnLPToken } from "../tokens/yearn";
 import { NormalToken } from "../tokens/normal";
 import { CurveLPToken } from "../tokens/curveLP";
+import type { Path, LPWithdrawPathFinder } from "./path";
 export declare class YearnVaultPathFinder implements LPWithdrawPathFinder {
     _vault: YearnLPToken;
     token: NormalToken | CurveLPToken;
     constructor(vault: YearnLPToken);
-    findWithdrawPaths(p: Path): Promise<Array<Path>>;
+    findWithdrawPaths(path: Path): Promise<Array<Path>>;
 }

package/lib/pathfinder/yVault.js

@@ -38,10 +38,11 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YearnVaultPathFinder = void 0;
 var ethers_1 = require("ethers");
-var types_1 = require("../types");
 var yearn_1 = require("../tokens/yearn");
 var token_1 = require("../tokens/token");
 var multicall_1 = require("../utils/multicall");
+var mappers_1 = require("../utils/mappers");
+var types_1 = require("../types");
 var YearnVaultPathFinder = /** @class */ (function () {
     function YearnVaultPathFinder(vault) {
         this._vault = vault;
@@ -49,23 +50,26 @@ var YearnVaultPathFinder = /** @class */ (function () {
         // Yearn Vault only has one lp action
         this.token = currentTokenData.underlying;
     }
-    YearnVaultPathFinder.prototype.findWithdrawPaths = function (p) {
+    // eslint-disable-next-line class-methods-use-this
+    YearnVaultPathFinder.prototype.findWithdrawPaths = function (path) {
         return __awaiter(this, void 0, void 0, function () {
-            var vaultBalances, _i, _a, _b, yVault, tokenData, currentBalance, vaultList, multicallData, prices, i, vault, vb;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var p, vaultBalances, vaultList, multicallData, prices, i, vault, vb, tokenAddress, adapterAddress, callData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        vaultBalances = {};
-                        for (_i = 0, _a = Object.entries(yearn_1.yearnTokens); _i < _a.length; _i++) {
-                            _b = _a[_i], yVault = _b[0], tokenData = _b[1];
-                            currentBalance = p.popBalance(yVault);
+                        p = Object.assign(Object.create(Object.getPrototypeOf(path)), path);
+                        vaultBalances = (0, mappers_1.objectEntries)(yearn_1.yearnTokens).reduce(function (acc, _a) {
+                            var yVault = _a[0], tokenData = _a[1];
+                            var typedVault = yVault;
+                            var currentBalance = p.popBalance(typedVault);
                             if (currentBalance.gt(1)) {
-                                vaultBalances[yVault] = {
+                                acc[typedVault] = {
                                     token: tokenData.underlying,
                                     balance: currentBalance
                                 };
                             }
-                        }
+                            return acc;
+                        }, {});
                         vaultList = Object.keys(vaultBalances);
                         multicallData = vaultList
                             .map(function (t) { return token_1.tokenDataByNetwork[p.networkType][t]; })
@@ -76,18 +80,17 @@ var YearnVaultPathFinder = /** @class */ (function () {
                         }); });
                         return [4 /*yield*/, (0, multicall_1.multicall)(multicallData, p.provider)];
                     case 1:
-                        prices = _c.sent();
-                        for (i = 0; i < vaultList.length; i++) {
+                        prices = _a.sent();
+                        for (i = 0; i < vaultList.length; i += 1) {
                             vault = vaultList[i];
                             vb = vaultBalances[vault];
                             p.balances[vb.token] = (p.balances[vb.token] || ethers_1.BigNumber.from(0)).add(ethers_1.BigNumber.from((vb === null || vb === void 0 ? void 0 : vb.balance) || 0).mul(prices[i]));
-                            p.calls.push({
-                                targetContract: p.creditManager.adapters[token_1.tokenDataByNetwork[p.networkType][vault]],
-                                callData: types_1.IYVault__factory.createInterface().encodeFunctionData("withdraw()")
-                            });
+                            tokenAddress = token_1.tokenDataByNetwork[p.networkType][vault];
+                            adapterAddress = p.creditManager.adapters[tokenAddress];
+                            callData = types_1.IYVault__factory.createInterface().encodeFunctionData("withdraw()");
+                            p.calls.push({ target: adapterAddress, callData: callData });
                         }
-                        return [4 /*yield*/, p.withdrawTokens()];
-                    case 2: return [2 /*return*/, _c.sent()];
+                        return [2 /*return*/, p.withdrawTokens()];
                 }
             });
         });

package/lib/payload/creditAccount.d.ts

@@ -1,26 +1,4 @@
-import { BigNumberish } from "ethers";
-export interface TokenBalancePayload {
-    token: string;
-    balance: BigNumberish;
-    isAllowed: boolean;
-}
-export interface CreditAccountDataPayload {
-    addr: string;
-    borrower: string;
-    inUse: boolean;
-    creditManager: string;
-    underlyingToken: string;
-    borrowedAmountPlusInterest: BigNumberish;
-    totalValue: BigNumberish;
-    healthFactor: BigNumberish;
-    borrowRate: BigNumberish;
-    balances?: Array<TokenBalancePayload>;
-}
-export interface CreditAccountDataExtendedPayload extends CreditAccountDataPayload {
-    repayAmount: BigNumberish;
-    liquidationAmount: BigNumberish;
-    canBeClosed?: boolean;
-    borrowedAmount: BigNumberish;
-    cumulativeIndexAtOpen: BigNumberish;
-    since: BigNumberish;
-}
+import { CreditAccountDataStruct } from "../types/contracts/core/DataCompressor";
+export declare type TokenBalancePayload = CreditAccountDataStruct["balances"];
+export declare type CreditAccountDataPayload = CreditAccountDataStruct;
+export declare type CreditAccountDataExtendedPayload = CreditAccountDataStruct;

package/lib/payload/creditManager.d.ts

@@ -1,33 +1,11 @@
 import { BigNumberish } from "ethers";
+import { CreditManagerDataStruct } from "../types/contracts/interfaces/IDataCompressor.sol/IDataCompressor";
 export interface AdapterPayload {
     allowedContract: string;
     adapter: string;
 }
-export interface CreditManagerDataPayload {
-    addr: string;
-    hasAccount?: boolean;
-    underlyingToken?: string;
-    isWETH?: boolean;
-    canBorrow?: boolean;
-    borrowRate?: BigNumberish;
-    minAmount?: BigNumberish;
-    maxAmount?: BigNumberish;
-    maxLeverageFactor?: BigNumberish;
-    availableLiquidity?: BigNumberish;
-    allowedTokens?: Array<string>;
-    adapters?: Array<AdapterPayload>;
-}
-export interface CreditManagerStatPayload {
-    addr: string;
-    underlyingToken?: string;
-    isWETH?: boolean;
-    canBorrow?: boolean;
-    borrowRate?: BigNumberish;
-    minAmount?: BigNumberish;
-    maxAmount?: BigNumberish;
-    maxLeverageFactor?: BigNumberish;
-    availableLiquidity?: BigNumberish;
-    allowedTokens?: Array<string>;
+export declare type CreditManagerDataPayload = CreditManagerDataStruct;
+export interface CreditManagerStatPayload extends CreditManagerDataPayload {
     allowedContracts?: Array<string>;
     uniqueUsers: number;
     openedAccountsCount?: number;

package/lib/payload/pool.d.ts

@@ -1,17 +1,2 @@
-import { BigNumberish } from "ethers";
-export interface PoolDataPayload {
-    addr: string;
-    underlyingToken: string;
-    dieselToken: string;
-    isWETH: boolean;
-    expectedLiquidity: BigNumberish;
-    expectedLiquidityLimit?: BigNumberish;
-    availableLiquidity: BigNumberish;
-    totalBorrowed: BigNumberish;
-    depositAPY_RAY: BigNumberish;
-    borrowAPY_RAY: BigNumberish;
-    dieselRate_RAY: BigNumberish;
-    withdrawFee: BigNumberish;
-    timestampLU?: BigNumberish;
-    cumulativeIndex_RAY?: BigNumberish;
-}
+import { PoolDataStruct } from "../types/contracts/interfaces/IDataCompressor.sol/IDataCompressor";
+export declare type PoolDataPayload = PoolDataStruct;

package/lib/payload/pool.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//

package/lib/strategies/curve.d.ts

@@ -8,36 +8,9 @@ export declare class CurveCalls {
     static add_all_liquidity_one_coin(i: BigNumberish, rateMinRAY: BigNumberish): string;
     static remove_liquidity_one_coin(token_amount: BigNumberish, i: BigNumberish, min_amount: BigNumberish): string;
     static remove_all_liquidity_one_coin(i: BigNumberish, minRateRAY: BigNumberish): string;
-    static add_liquidity(amounts: [BigNumberish, BigNumberish] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ], min_mint_amount: BigNumberish): string;
-    static remove_liquidity(amount: BigNumberish, min_amounts: [BigNumberish, BigNumberish] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ]): string;
-    static remove_liquidity_imbalance(amounts: [BigNumberish, BigNumberish] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ], max_burn_amount: BigNumberish): string;
+    static add_liquidity(amounts: [BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish, BigNumberish], min_mint_amount: BigNumberish): string;
+    static remove_liquidity(amount: BigNumberish, min_amounts: [BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish, BigNumberish]): string;
+    static remove_liquidity_imbalance(amounts: [BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish, BigNumberish], max_burn_amount: BigNumberish): string;
 }
 export declare class CurveMulticaller {
     private readonly _address;
@@ -55,34 +28,7 @@ export declare class CurveMulticaller {
         target: string;
         callData: string;
     };
-    add_liquidity(amounts: [BigNumberish, BigNumberish] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ], min_mint_amount: BigNumberish): MultiCallStruct;
-    remove_liquidity(amount: BigNumberish, min_amounts: [BigNumberish, BigNumberish] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ]): MultiCallStruct;
-    remove_liquidity_imbalance(amounts: [BigNumberish, BigNumberish] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ] | [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish
-    ], max_burn_amount: BigNumberish): MultiCallStruct;
+    add_liquidity(amounts: [BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish, BigNumberish], min_mint_amount: BigNumberish): MultiCallStruct;
+    remove_liquidity(amount: BigNumberish, min_amounts: [BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish, BigNumberish]): MultiCallStruct;
+    remove_liquidity_imbalance(amounts: [BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish] | [BigNumberish, BigNumberish, BigNumberish, BigNumberish], max_burn_amount: BigNumberish): MultiCallStruct;
 }

package/lib/strategies/curve.js

@@ -34,6 +34,8 @@ var CurveCalls = /** @class */ (function () {
                 return types_1.CurveV1Adapter3Assets__factory.createInterface().encodeFunctionData("add_liquidity", [amounts, min_mint_amount]);
             case 4:
                 return types_1.CurveV1Adapter4Assets__factory.createInterface().encodeFunctionData("add_liquidity", [amounts, min_mint_amount]);
+            default:
+                throw new Error("Wrong calls number: add_liquidity");
         }
     };
     CurveCalls.remove_liquidity = function (amount, min_amounts) {
@@ -44,6 +46,8 @@ var CurveCalls = /** @class */ (function () {
                 return types_1.CurveV1Adapter3Assets__factory.createInterface().encodeFunctionData("remove_liquidity", [amount, min_amounts]);
             case 4:
                 return types_1.CurveV1Adapter4Assets__factory.createInterface().encodeFunctionData("remove_liquidity", [amount, min_amounts]);
+            default:
+                throw new Error("Wrong calls number: remove_liquidity");
         }
     };
     CurveCalls.remove_liquidity_imbalance = function (amounts, max_burn_amount) {
@@ -54,6 +58,8 @@ var CurveCalls = /** @class */ (function () {
                 return types_1.CurveV1Adapter3Assets__factory.createInterface().encodeFunctionData("remove_liquidity_imbalance", [amounts, max_burn_amount]);
             case 4:
                 return types_1.CurveV1Adapter4Assets__factory.createInterface().encodeFunctionData("remove_liquidity_imbalance", [amounts, max_burn_amount]);
+            default:
+                throw new Error("Wrong calls number: remove_liquidity_imbalance");
         }
     };
     return CurveCalls;

package/lib/strategies/uniswapV2.js

@@ -6,29 +6,13 @@ var UniswapV2Calls = /** @class */ (function () {
     function UniswapV2Calls() {
     }
     UniswapV2Calls.swapExactTokensForTokens = function (amountIn, amountOutMin, path, to, deadline) {
-        return types_1.UniswapV2Adapter__factory.createInterface().encodeFunctionData("swapExactTokensForTokens", [
-            amountIn,
-            amountOutMin,
-            path,
-            to,
-            deadline
-        ]);
+        return types_1.UniswapV2Adapter__factory.createInterface().encodeFunctionData("swapExactTokensForTokens", [amountIn, amountOutMin, path, to, deadline]);
     };
     UniswapV2Calls.swapTokensForExactTokens = function (amountOut, amountInMax, path, to, deadline) {
-        return types_1.UniswapV2Adapter__factory.createInterface().encodeFunctionData("swapTokensForExactTokens", [
-            amountOut,
-            amountInMax,
-            path,
-            to,
-            deadline
-        ]);
+        return types_1.UniswapV2Adapter__factory.createInterface().encodeFunctionData("swapTokensForExactTokens", [amountOut, amountInMax, path, to, deadline]);
     };
     UniswapV2Calls.swapAllTokensForTokens = function (rateMinRAY, path, deadline) {
-        return types_1.UniswapV2Adapter__factory.createInterface().encodeFunctionData("swapAllTokensForTokens", [
-            rateMinRAY,
-            path,
-            deadline
-        ]);
+        return types_1.UniswapV2Adapter__factory.createInterface().encodeFunctionData("swapAllTokensForTokens", [rateMinRAY, path, deadline]);
     };
     return UniswapV2Calls;
 }());

package/lib/strategies/uniswapV3.js

@@ -1,5 +1,5 @@
 "use strict";
-//import { BigNumberish } from "ethers";
+// import { BigNumberish } from "ethers";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV3Multicaller = exports.UniswapV3Calls = void 0;
 var types_1 = require("../types");

package/lib/strategies/yearn.js

@@ -8,14 +8,15 @@ var YearnV2Calls = /** @class */ (function () {
     YearnV2Calls.deposit = function (amount, recipient) {
         var contractInterface = types_1.YearnV2Adapter__factory.createInterface();
         if (amount && recipient) {
-            return contractInterface.encodeFunctionData("deposit(uint256,address)", [amount, recipient]);
+            return contractInterface.encodeFunctionData("deposit(uint256,address)", [
+                amount,
+                recipient
+            ]);
         }
-        else if (amount) {
+        if (amount) {
             return contractInterface.encodeFunctionData("deposit(uint256)", [amount]);
         }
-        else {
-            return contractInterface.encodeFunctionData("deposit()");
-        }
+        return contractInterface.encodeFunctionData("deposit()");
     };
     YearnV2Calls.withdraw = function (maxShares, recipient, maxLoss) {
         var contractInterface = types_1.YearnV2Adapter__factory.createInterface();
@@ -23,14 +24,17 @@ var YearnV2Calls = /** @class */ (function () {
             return contractInterface.encodeFunctionData("withdraw(uint256,address,uint256)", [maxShares, recipient, maxLoss]);
         }
         if (maxShares && recipient) {
-            return contractInterface.encodeFunctionData("withdraw(uint256,address)", [maxShares, recipient]);
-        }
-        else if (maxShares) {
-            return contractInterface.encodeFunctionData("withdraw(uint256)", [maxShares]);
+            return contractInterface.encodeFunctionData("withdraw(uint256,address)", [
+                maxShares,
+                recipient
+            ]);
         }
-        else {
-            return contractInterface.encodeFunctionData("withdraw()");
+        if (maxShares) {
+            return contractInterface.encodeFunctionData("withdraw(uint256)", [
+                maxShares
+            ]);
         }
+        return contractInterface.encodeFunctionData("withdraw()");
     };
     return YearnV2Calls;
 }());