@gearbox-protocol/sdk 0.0.102 → 0.0.105

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[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, tokenAddress, adapterAddress, callData;
-            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,8 +80,8 @@ 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]));
@@ -86,8 +90,7 @@ var YearnVaultPathFinder = /** @class */ (function () {
                             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/strategies/convex.d.ts

@@ -1,4 +1,7 @@
 import { BigNumberish } from "ethers";
+import { ConvexPoolContract } from "../contracts/contracts";
+import { NetworkType } from "../core/constants";
+import { CreditManagerData } from "../core/creditManager";
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
 export declare class ConvexBoosterCalls {
     static deposit(pid: BigNumberish, amount: BigNumberish, stake: boolean): string;
@@ -20,6 +23,7 @@ export declare class ConvexClaimZapCalls {
 export declare class ConvexBoosterMulticaller {
     private readonly _address;
     constructor(address: string);
+    static connect(address: string): ConvexBoosterMulticaller;
     deposit(pid: BigNumberish, amount: BigNumberish, stake: boolean): MultiCallStruct;
     depositAll(pid: BigNumberish, stake: boolean): MultiCallStruct;
     withdraw(pid: BigNumberish, amount: BigNumberish): MultiCallStruct;
@@ -28,6 +32,7 @@ export declare class ConvexBoosterMulticaller {
 export declare class ConvexPoolMulticaller {
     private readonly _address;
     constructor(address: string);
+    static connect(address: string): ConvexPoolMulticaller;
     stake(amount: BigNumberish): MultiCallStruct;
     stakeAll(): MultiCallStruct;
     withdraw(amount: BigNumberish, claim: boolean): MultiCallStruct;
@@ -41,5 +46,12 @@ export declare class ConvexPoolMulticaller {
 export declare class ConvexClaimZapMulticaller {
     private readonly _address;
     constructor(address: string);
+    static connect(address: string): ConvexClaimZapMulticaller;
     claimRewards(rewardContracts: Array<string>, extraRewardContracts: Array<string>, tokenRewardContracts: Array<string>, tokenRewardTokens: Array<string>, depositCrvMaxAmount: BigNumberish, minAmountOut: BigNumberish, depositCvxMaxAmount: BigNumberish, spendCvxAmount: BigNumberish, options: BigNumberish): MultiCallStruct;
 }
+export declare class ConvexStrategies {
+    static underlyingToStakedConvex(data: CreditManagerData, network: NetworkType, convexPool: ConvexPoolContract, underlyingAmount: BigNumberish): MultiCallStruct[];
+    static stakedConvexToUnderlying(data: CreditManagerData, network: NetworkType, convexPool: ConvexPoolContract, convexLpAmount: BigNumberish, sellRewards: boolean): MultiCallStruct[];
+    static allStakedConvexToUnderlying(data: CreditManagerData, network: NetworkType, convexPool: ConvexPoolContract, sellRewards: boolean): MultiCallStruct[];
+    static sellRewards(data: CreditManagerData, network: NetworkType, convexPool: ConvexPoolContract): MultiCallStruct[];
+}

package/lib/strategies/convex.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConvexClaimZapMulticaller = exports.ConvexPoolMulticaller = exports.ConvexBoosterMulticaller = exports.ConvexClaimZapCalls = exports.ConvexPoolCalls = exports.ConvexBoosterCalls = void 0;
+exports.ConvexStrategies = exports.ConvexClaimZapMulticaller = exports.ConvexPoolMulticaller = exports.ConvexBoosterMulticaller = exports.ConvexClaimZapCalls = exports.ConvexPoolCalls = exports.ConvexBoosterCalls = void 0;
+var contracts_1 = require("../contracts/contracts");
+var token_1 = require("../tokens/token");
 var types_1 = require("../types");
+var curve_1 = require("./curve");
+var uniswapV2_1 = require("./uniswapV2");
 var ConvexBoosterCalls = /** @class */ (function () {
     function ConvexBoosterCalls() {
     }
@@ -67,6 +71,9 @@ var ConvexBoosterMulticaller = /** @class */ (function () {
     function ConvexBoosterMulticaller(address) {
         this._address = address;
     }
+    ConvexBoosterMulticaller.connect = function (address) {
+        return new ConvexBoosterMulticaller(address);
+    };
     ConvexBoosterMulticaller.prototype.deposit = function (pid, amount, stake) {
         return {
             target: this._address,
@@ -98,6 +105,9 @@ var ConvexPoolMulticaller = /** @class */ (function () {
     function ConvexPoolMulticaller(address) {
         this._address = address;
     }
+    ConvexPoolMulticaller.connect = function (address) {
+        return new ConvexPoolMulticaller(address);
+    };
     ConvexPoolMulticaller.prototype.stake = function (amount) {
         return {
             target: this._address,
@@ -141,6 +151,9 @@ var ConvexClaimZapMulticaller = /** @class */ (function () {
     function ConvexClaimZapMulticaller(address) {
         this._address = address;
     }
+    ConvexClaimZapMulticaller.connect = function (address) {
+        return new ConvexClaimZapMulticaller(address);
+    };
     ConvexClaimZapMulticaller.prototype.claimRewards = function (rewardContracts, extraRewardContracts, tokenRewardContracts, tokenRewardTokens, depositCrvMaxAmount, minAmountOut, depositCvxMaxAmount, spendCvxAmount, options) {
         return {
             target: this._address,
@@ -150,3 +163,63 @@ var ConvexClaimZapMulticaller = /** @class */ (function () {
     return ConvexClaimZapMulticaller;
 }());
 exports.ConvexClaimZapMulticaller = ConvexClaimZapMulticaller;
+var ConvexStrategies = /** @class */ (function () {
+    function ConvexStrategies() {
+    }
+    ConvexStrategies.underlyingToStakedConvex = function (data, network, convexPool, underlyingAmount) {
+        var calls = [];
+        var convexParams = contracts_1.contractParams[convexPool];
+        var stakedToken = convexParams.stakedToken;
+        var stakedTokenParams = token_1.supportedTokens[stakedToken];
+        var curveLpToken = stakedTokenParams.underlying;
+        var curveLpTokenData = token_1.supportedTokens[curveLpToken];
+        var curvePool = curveLpTokenData.pool;
+        calls = curve_1.CurveStrategies.underlyingToCurveLP(data, network, curvePool, underlyingAmount);
+        calls.push(ConvexBoosterMulticaller.connect(data.adapters[contracts_1.contractsByNetwork[network].CONVEX_BOOSTER]).depositAll(stakedTokenParams.pid, true));
+        return calls;
+    };
+    ConvexStrategies.stakedConvexToUnderlying = function (data, network, convexPool, convexLpAmount, sellRewards) {
+        var calls = [];
+        var convexParams = contracts_1.contractParams[convexPool];
+        var stakedToken = convexParams.stakedToken;
+        var stakedTokenParams = token_1.supportedTokens[stakedToken];
+        var curveLpToken = stakedTokenParams.underlying;
+        var curveLpTokenData = token_1.supportedTokens[curveLpToken];
+        var curvePool = curveLpTokenData.pool;
+        calls.push(ConvexPoolMulticaller.connect(data.adapters[contracts_1.contractsByNetwork[network][convexPool]]).withdrawAndUnwrap(convexLpAmount, true));
+        calls.push.apply(calls, curve_1.CurveStrategies.allCurveLPToUnderlying(data, network, curvePool));
+        if (sellRewards) {
+            calls.push.apply(calls, ConvexStrategies.sellRewards(data, network, convexPool));
+        }
+        return calls;
+    };
+    ConvexStrategies.allStakedConvexToUnderlying = function (data, network, convexPool, sellRewards) {
+        var calls = [];
+        var convexParams = contracts_1.contractParams[convexPool];
+        var stakedToken = convexParams.stakedToken;
+        var stakedTokenParams = token_1.supportedTokens[stakedToken];
+        var curveLpToken = stakedTokenParams.underlying;
+        var curveLpTokenData = token_1.supportedTokens[curveLpToken];
+        var curvePool = curveLpTokenData.pool;
+        calls.push(ConvexPoolMulticaller.connect(data.adapters[contracts_1.contractsByNetwork[network][convexPool]]).withdrawAllAndUnwrap(true));
+        calls.push.apply(calls, curve_1.CurveStrategies.allCurveLPToUnderlying(data, network, curvePool));
+        if (sellRewards) {
+            calls.push.apply(calls, ConvexStrategies.sellRewards(data, network, convexPool));
+        }
+        return calls;
+    };
+    ConvexStrategies.sellRewards = function (data, network, convexPool) {
+        var calls = [];
+        var convexParams = contracts_1.contractParams[convexPool];
+        calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapAllTokensForTokens(0, [token_1.tokenDataByNetwork[network].CRV, data.underlyingToken], Math.floor(new Date().getTime() / 1000) + 3600), uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapAllTokensForTokens(0, [token_1.tokenDataByNetwork[network].CVX, data.underlyingToken], Math.floor(new Date().getTime() / 1000) + 3600));
+        convexParams.extraRewards.forEach(function (extraReward) {
+            uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapAllTokensForTokens(0, [
+                token_1.tokenDataByNetwork[network][extraReward.rewardToken],
+                data.underlyingToken
+            ], Math.floor(new Date().getTime() / 1000) + 3600);
+        });
+        return calls;
+    };
+    return ConvexStrategies;
+}());
+exports.ConvexStrategies = ConvexStrategies;

package/lib/strategies/creditFacade.d.ts

@@ -9,6 +9,7 @@ export declare class CreditFacadeCalls {
 export declare class CreditFacadeMulticaller {
     private readonly _address;
     constructor(address: string);
+    static connect(address: string): CreditFacadeMulticaller;
     addCollateral(onBehalfOf: string, token: string, amount: BigNumberish): MultiCallStruct;
     increaseDebt(amount: BigNumberish): MultiCallStruct;
     decreaseDebt(amount: BigNumberish): MultiCallStruct;

package/lib/strategies/creditFacade.js

@@ -24,6 +24,9 @@ var CreditFacadeMulticaller = /** @class */ (function () {
     function CreditFacadeMulticaller(address) {
         this._address = address;
     }
+    CreditFacadeMulticaller.connect = function (address) {
+        return new CreditFacadeMulticaller(address);
+    };
     CreditFacadeMulticaller.prototype.addCollateral = function (onBehalfOf, token, amount) {
         return {
             target: this._address,

package/lib/strategies/curve.d.ts

@@ -1,4 +1,7 @@
 import { BigNumberish } from "ethers";
+import { CurvePoolContract } from "../contracts/contracts";
+import { NetworkType } from "../core/constants";
+import { CreditManagerData } from "../core/creditManager";
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
 export declare class CurveCalls {
     static exchange(i: BigNumberish, j: BigNumberish, dx: BigNumberish, min_dy: BigNumberish): string;
@@ -8,40 +11,14 @@ 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;
     constructor(address: string);
+    static connect(address: string): CurveMulticaller;
     exchange(i: BigNumberish, j: BigNumberish, dx: BigNumberish, min_dy: BigNumberish): MultiCallStruct;
     exchange_all(i: BigNumberish, j: BigNumberish, rateMinRAY: BigNumberish): MultiCallStruct;
     exchange_underlying(i: BigNumberish, j: BigNumberish, dx: BigNumberish, min_dy: BigNumberish): MultiCallStruct;
@@ -55,34 +32,12 @@ 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;
+}
+export declare class CurveStrategies {
+    static underlyingToCurveLP(data: CreditManagerData, network: NetworkType, curvePool: CurvePoolContract, underlyingAmount: BigNumberish): MultiCallStruct[];
+    static curveLPToUnderlying(data: CreditManagerData, network: NetworkType, curvePool: CurvePoolContract, curveLPAmount: BigNumberish): MultiCallStruct[];
+    static allCurveLPToUnderlying(data: CreditManagerData, network: NetworkType, curvePool: CurvePoolContract): MultiCallStruct[];
 }

package/lib/strategies/curve.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CurveMulticaller = exports.CurveCalls = void 0;
+exports.CurveStrategies = exports.CurveMulticaller = exports.CurveCalls = void 0;
+var contracts_1 = require("../contracts/contracts");
+var constants_1 = require("../core/constants");
+var token_1 = require("../tokens/token");
 var types_1 = require("../types");
+var uniswapV2_1 = require("./uniswapV2");
 var CurveCalls = /** @class */ (function () {
     function CurveCalls() {
     }
@@ -34,6 +38,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 +50,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 +62,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;
@@ -63,6 +73,9 @@ var CurveMulticaller = /** @class */ (function () {
     function CurveMulticaller(address) {
         this._address = address;
     }
+    CurveMulticaller.connect = function (address) {
+        return new CurveMulticaller(address);
+    };
     CurveMulticaller.prototype.exchange = function (i, j, dx, min_dy) {
         return {
             target: this._address,
@@ -126,3 +139,63 @@ var CurveMulticaller = /** @class */ (function () {
     return CurveMulticaller;
 }());
 exports.CurveMulticaller = CurveMulticaller;
+var CurveStrategies = /** @class */ (function () {
+    function CurveStrategies() {
+    }
+    CurveStrategies.underlyingToCurveLP = function (data, network, curvePool, underlyingAmount) {
+        var calls = [];
+        var curveParams = contracts_1.contractParams[curvePool];
+        var tokenToDeposit = curveParams.tokens[0];
+        if (data.underlyingToken !== token_1.tokenDataByNetwork[network][tokenToDeposit]) {
+            calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapExactTokensForTokens(underlyingAmount, 0, [data.underlyingToken, token_1.tokenDataByNetwork[network][tokenToDeposit]], constants_1.ADDRESS_0X0, Math.floor(new Date().getTime() / 1000) + 3600));
+        }
+        calls.push(CurveMulticaller.connect(data.adapters[contracts_1.contractsByNetwork[network][curvePool]]).add_all_liquidity_one_coin(0, 0));
+        return calls;
+    };
+    CurveStrategies.curveLPToUnderlying = function (data, network, curvePool, curveLPAmount) {
+        var calls = [];
+        var curveParams = contracts_1.contractParams[curvePool];
+        var curveContractAddress;
+        if (curveParams.wrapper) {
+            curveContractAddress =
+                data.adapters[contracts_1.contractsByNetwork[network][curveParams.wrapper]];
+        }
+        else {
+            curveContractAddress =
+                data.adapters[contracts_1.contractsByNetwork[network][curvePool]];
+        }
+        calls.push(CurveMulticaller.connect(curveContractAddress).remove_liquidity_one_coin(curveLPAmount, 0, 0));
+        if (token_1.tokenDataByNetwork[network][curveParams.tokens[0]] !==
+            data.underlyingToken) {
+            calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapAllTokensForTokens(0, [
+                token_1.tokenDataByNetwork[network][curveParams.tokens[0]],
+                data.underlyingToken
+            ], Math.floor(new Date().getTime() / 1000) + 3600));
+        }
+        return calls;
+    };
+    CurveStrategies.allCurveLPToUnderlying = function (data, network, curvePool) {
+        var calls = [];
+        var curveParams = contracts_1.contractParams[curvePool];
+        var curveContractAddress;
+        if (curveParams.wrapper) {
+            curveContractAddress =
+                data.adapters[contracts_1.contractsByNetwork[network][curveParams.wrapper]];
+        }
+        else {
+            curveContractAddress =
+                data.adapters[contracts_1.contractsByNetwork[network][curvePool]];
+        }
+        calls.push(CurveMulticaller.connect(curveContractAddress).remove_all_liquidity_one_coin(0, 0));
+        if (token_1.tokenDataByNetwork[network][curveParams.tokens[0]] !==
+            data.underlyingToken) {
+            calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapAllTokensForTokens(0, [
+                token_1.tokenDataByNetwork[network][curveParams.tokens[0]],
+                data.underlyingToken
+            ], Math.floor(new Date().getTime() / 1000) + 3600));
+        }
+        return calls;
+    };
+    return CurveStrategies;
+}());
+exports.CurveStrategies = CurveStrategies;

package/lib/strategies/lido.d.ts

@@ -1,4 +1,6 @@
 import { BigNumberish } from "ethers";
+import { CreditManagerData } from "../core/creditManager";
+import { NetworkType } from "../core/constants";
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
 export declare class LidoCalls {
     static submit(amount: BigNumberish): string;
@@ -7,6 +9,10 @@ export declare class LidoCalls {
 export declare class LidoMulticaller {
     private readonly _address;
     constructor(address: string);
+    static connect(address: string): LidoMulticaller;
     submit(amount: BigNumberish): MultiCallStruct;
     submitAll(): MultiCallStruct;
 }
+export declare class LidoStrategies {
+    static mintSteth(data: CreditManagerData, network: NetworkType, underlyingAmount: BigNumberish): MultiCallStruct[];
+}

package/lib/strategies/lido.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LidoMulticaller = exports.LidoCalls = void 0;
+exports.LidoStrategies = exports.LidoMulticaller = exports.LidoCalls = void 0;
+var constants_1 = require("../core/constants");
+var contracts_1 = require("../contracts/contracts");
+var token_1 = require("../tokens/token");
 var types_1 = require("../types");
+var uniswapV2_1 = require("./uniswapV2");
 var LidoCalls = /** @class */ (function () {
     function LidoCalls() {
     }
@@ -18,6 +22,9 @@ var LidoMulticaller = /** @class */ (function () {
     function LidoMulticaller(address) {
         this._address = address;
     }
+    LidoMulticaller.connect = function (address) {
+        return new LidoMulticaller(address);
+    };
     LidoMulticaller.prototype.submit = function (amount) {
         return {
             target: this._address,
@@ -33,3 +40,18 @@ var LidoMulticaller = /** @class */ (function () {
     return LidoMulticaller;
 }());
 exports.LidoMulticaller = LidoMulticaller;
+var LidoStrategies = /** @class */ (function () {
+    function LidoStrategies() {
+    }
+    LidoStrategies.mintSteth = function (data, network, underlyingAmount) {
+        var calls = [];
+        // This should be a pathfinder call
+        if (!data.isWETH) {
+            calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapExactTokensForTokens(underlyingAmount, 0, [data.underlyingToken, token_1.tokenDataByNetwork[network].WETH], constants_1.ADDRESS_0X0, Math.floor(new Date().getTime() / 1000) + 3600));
+        }
+        calls.push(LidoMulticaller.connect(data.adapters[contracts_1.contractsByNetwork[network].LIDO_STETH_GATEWAY]).submitAll());
+        return calls;
+    };
+    return LidoStrategies;
+}());
+exports.LidoStrategies = LidoStrategies;