@gearbox-protocol/sdk 0.0.101 → 0.0.104

package/lib/strategies/curve.d.ts

@@ -1,4 +1,7 @@
 import { BigNumberish } from "ethers";
+import { CurvePoolContract } from "src/contracts/contracts";
+import { NetworkType } from "src/core/constants";
+import { CreditManagerData } from "src/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("src/contracts/contracts");
+var constants_1 = require("src/core/constants");
+var token_1 = require("src/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 "src/core/creditManager";
+import { NetworkType } from "src/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("src/core/constants");
+var contracts_1 = require("src/contracts/contracts");
+var token_1 = require("src/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;

package/lib/strategies/uniswapV2.d.ts

@@ -8,6 +8,7 @@ export declare class UniswapV2Calls {
 export declare class UniswapV2Multicaller {
     private readonly _address;
     constructor(address: string);
+    static connect(address: string): UniswapV2Multicaller;
     swapExactTokensForTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, path: Array<string>, to: string, deadline: BigNumberish): MultiCallStruct;
     swapTokensForExactTokens(amountOut: BigNumberish, amountInMax: BigNumberish, path: Array<string>, to: string, deadline: BigNumberish): MultiCallStruct;
     swapAllTokensForTokens(rateMinRAY: BigNumberish, path: Array<string>, deadline: BigNumberish): MultiCallStruct;

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;
 }());
@@ -37,6 +21,9 @@ var UniswapV2Multicaller = /** @class */ (function () {
     function UniswapV2Multicaller(address) {
         this._address = address;
     }
+    UniswapV2Multicaller.connect = function (address) {
+        return new UniswapV2Multicaller(address);
+    };
     UniswapV2Multicaller.prototype.swapExactTokensForTokens = function (amountIn, amountOutMin, path, to, deadline) {
         return {
             target: this._address,

package/lib/strategies/uniswapV3.d.ts

@@ -11,6 +11,7 @@ export declare class UniswapV3Calls {
 export declare class UniswapV3Multicaller {
     private readonly _address;
     constructor(address: string);
+    static connect(address: string): UniswapV3Multicaller;
     exactInputSingle(params: ISwapRouter.ExactInputSingleParamsStructOutput): MultiCallStruct;
     exactAllInputSingle(params: IUniswapV3Adapter.ExactAllInputSingleParamsStructOutput): MultiCallStruct;
     exactInput(params: ISwapRouter.ExactInputParamsStructOutput): MultiCallStruct;

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");
@@ -31,6 +31,9 @@ var UniswapV3Multicaller = /** @class */ (function () {
     function UniswapV3Multicaller(address) {
         this._address = address;
     }
+    UniswapV3Multicaller.connect = function (address) {
+        return new UniswapV3Multicaller(address);
+    };
     UniswapV3Multicaller.prototype.exactInputSingle = function (params) {
         return {
             target: this._address,

package/lib/strategies/yearn.d.ts

@@ -1,4 +1,7 @@
 import { BigNumberish } from "ethers";
+import { YearnVaultContract } from "src/contracts/contracts";
+import { NetworkType } from "src/core/constants";
+import { CreditManagerData } from "src/core/creditManager";
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
 export declare class YearnV2Calls {
     static deposit(amount?: BigNumberish, recipient?: string): string;
@@ -7,6 +10,11 @@ export declare class YearnV2Calls {
 export declare class YearnV2Multicaller {
     private readonly _address;
     constructor(address: string);
+    static connect(address: string): YearnV2Multicaller;
     deposit(amount?: BigNumberish, recipient?: string): MultiCallStruct;
     withdraw(maxShares?: BigNumberish, recipient?: string, maxLoss?: BigNumberish): MultiCallStruct;
 }
+export declare class YearnV2Strategies {
+    static underlyingToYearn(data: CreditManagerData, network: NetworkType, yearnVault: YearnVaultContract, underlyingAmount: BigNumberish): void;
+    static yearnToUnderlying(data: CreditManagerData, network: NetworkType, yearnVault: YearnVaultContract, yearnSharesAmount: BigNumberish): void;
+}

package/lib/strategies/yearn.js

@@ -1,21 +1,37 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.YearnV2Multicaller = exports.YearnV2Calls = void 0;
+exports.YearnV2Strategies = exports.YearnV2Multicaller = exports.YearnV2Calls = void 0;
+var contracts_1 = require("src/contracts/contracts");
+var constants_1 = require("src/core/constants");
+var token_1 = require("src/tokens/token");
+var tokenType_1 = require("src/tokens/tokenType");
 var types_1 = require("../types");
+var curve_1 = require("./curve");
+var uniswapV2_1 = require("./uniswapV2");
 var YearnV2Calls = /** @class */ (function () {
     function YearnV2Calls() {
     }
     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 +39,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;
 }());
@@ -39,6 +58,9 @@ var YearnV2Multicaller = /** @class */ (function () {
     function YearnV2Multicaller(address) {
         this._address = address;
     }
+    YearnV2Multicaller.connect = function (address) {
+        return new YearnV2Multicaller(address);
+    };
     YearnV2Multicaller.prototype.deposit = function (amount, recipient) {
         return {
             target: this._address,
@@ -54,3 +76,61 @@ var YearnV2Multicaller = /** @class */ (function () {
     return YearnV2Multicaller;
 }());
 exports.YearnV2Multicaller = YearnV2Multicaller;
+var YearnV2Strategies = /** @class */ (function () {
+    function YearnV2Strategies() {
+    }
+    YearnV2Strategies.underlyingToYearn = function (data, network, yearnVault, underlyingAmount) {
+        var calls = [];
+        var vaultParams = contracts_1.contractParams[yearnVault];
+        var yearnToken = vaultParams.shareToken;
+        var yearnParams = token_1.supportedTokens[yearnToken];
+        if (yearnParams.type === tokenType_1.TokenType.YEARN_VAULT) {
+            if (data.underlyingToken !==
+                token_1.tokenDataByNetwork[network][yearnParams.underlying]) {
+                // This should be a pathfinder call
+                calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapExactTokensForTokens(underlyingAmount, 0, [
+                    data.underlyingToken,
+                    token_1.tokenDataByNetwork[network][yearnParams.underlying]
+                ], constants_1.ADDRESS_0X0, Math.floor(new Date().getTime() / 1000) + 3600));
+            }
+        }
+        else if (yearnParams.type === tokenType_1.TokenType.YEARN_VAULT_OF_CURVE_LP ||
+            yearnParams.type === tokenType_1.TokenType.YEARN_VAULT_OF_META_CURVE_LP) {
+            var curveTokenParams = token_1.supportedTokens[yearnParams.underlying];
+            var curvePool = curveTokenParams.pool;
+            calls = curve_1.CurveStrategies.underlyingToCurveLP(data, network, curvePool, underlyingAmount);
+        }
+        else {
+            throw new Error("Yearn vault type unknown");
+        }
+        calls.push(YearnV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network][yearnVault]]).deposit());
+    };
+    YearnV2Strategies.yearnToUnderlying = function (data, network, yearnVault, yearnSharesAmount) {
+        var calls = [];
+        var vaultParams = contracts_1.contractParams[yearnVault];
+        var yearnToken = vaultParams.shareToken;
+        var yearnParams = token_1.supportedTokens[yearnToken];
+        calls.push(YearnV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network][yearnVault]]).withdraw(yearnSharesAmount));
+        if (yearnParams.type === tokenType_1.TokenType.YEARN_VAULT) {
+            if (data.underlyingToken !==
+                token_1.tokenDataByNetwork[network][yearnParams.underlying]) {
+                // This should be a pathfinder call
+                calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER]).swapAllTokensForTokens(0, [
+                    token_1.tokenDataByNetwork[network][yearnParams.underlying],
+                    data.underlyingToken
+                ], Math.floor(new Date().getTime() / 1000) + 3600));
+            }
+        }
+        else if (yearnParams.type === tokenType_1.TokenType.YEARN_VAULT_OF_CURVE_LP ||
+            yearnParams.type === tokenType_1.TokenType.YEARN_VAULT_OF_META_CURVE_LP) {
+            var curveTokenParams = token_1.supportedTokens[yearnParams.underlying];
+            var curvePool = curveTokenParams.pool;
+            calls = __spreadArray(__spreadArray([], calls, true), curve_1.CurveStrategies.allCurveLPToUnderlying(data, network, curvePool), true);
+        }
+        else {
+            throw new Error("Yearn vault type unknown");
+        }
+    };
+    return YearnV2Strategies;
+}());
+exports.YearnV2Strategies = YearnV2Strategies;

package/lib/tokens/convex.d.ts

@@ -1,7 +1,7 @@
 import { TradeAction } from "../pathfinder/tradeTypes";
-import { TokenBase } from "./token";
-import { ConvexPoolContract } from "../contracts/contracts";
-import { CurveLPToken } from "./curveLP";
+import type { TokenBase } from "./token";
+import type { ConvexPoolContract } from "../contracts/contracts";
+import type { CurveLPToken } from "./curveLP";
 import { TokenType } from "./tokenType";
 export declare type ConvexLPToken = "cvx3Crv" | "cvxsteCRV" | "cvxFRAX3CRV" | "cvxLUSD3CRV" | "cvxcrvPlain3andSUSD" | "cvxgusd3CRV";
 export declare type ConvexStakedPhantomToken = "stkcvx3Crv" | "stkcvxsteCRV" | "stkcvxFRAX3CRV" | "stkcvxLUSD3CRV" | "stkcvxcrvPlain3andSUSD" | "stkcvxgusd3CRV";

package/lib/tokens/curveLP.d.ts

@@ -1,7 +1,8 @@
+import { BigNumber } from "ethers";
+import type { CurvePoolContract } from "src/contracts/contracts";
 import { TradeAction } from "../pathfinder/tradeTypes";
-import { SupportedToken, TokenBase } from "./token";
+import type { SupportedToken, TokenBase } from "./token";
 import { PartialRecord } from "../utils/types";
-import { BigNumber } from "ethers";
 import { TokenType } from "./tokenType";
 export declare type CurveLPToken = "3Crv" | "steCRV" | "FRAX3CRV" | "LUSD3CRV" | "crvPlain3andSUSD" | "gusd3CRV";
 export declare type CurveLPTokenData = {
@@ -9,11 +10,15 @@ export declare type CurveLPTokenData = {
     type: TokenType.CURVE_LP;
     swapActions?: Array<TradeAction>;
     lpActions: Array<TradeAction>;
+    pool: CurvePoolContract;
+    wrapper?: CurvePoolContract;
 } & TokenBase;
 export declare type MetaCurveLPTokenData = {
     symbol: CurveLPToken;
     type: TokenType.META_CURVE_LP;
     lpActions: Array<TradeAction>;
+    pool: CurvePoolContract;
+    wrapper?: CurvePoolContract;
 } & TokenBase;
 export declare const Curve3CrvUnderlyingTokenIndex: PartialRecord<SupportedToken, BigNumber>;
 export declare const curveTokens: Record<CurveLPToken, CurveLPTokenData | MetaCurveLPTokenData>;

package/lib/tokens/curveLP.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.curveTokens = exports.Curve3CrvUnderlyingTokenIndex = void 0;
-var tradeTypes_1 = require("../pathfinder/tradeTypes");
 var ethers_1 = require("ethers");
+var tradeTypes_1 = require("../pathfinder/tradeTypes");
 var tokenType_1 = require("./tokenType");
 exports.Curve3CrvUnderlyingTokenIndex = {
     DAI: ethers_1.BigNumber.from(0),
@@ -16,6 +16,7 @@ exports.curveTokens = {
         decimals: 18,
         symbol: "3Crv",
         type: tokenType_1.TokenType.CURVE_LP,
+        pool: "CURVE_3CRV_POOL",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.CurveWithdrawLP,
@@ -39,6 +40,7 @@ exports.curveTokens = {
         decimals: 18,
         symbol: "steCRV",
         type: tokenType_1.TokenType.CURVE_LP,
+        pool: "CURVE_STETH_GATEWAY",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.CurveWithdrawLP,
@@ -62,6 +64,8 @@ exports.curveTokens = {
         decimals: 18,
         symbol: "crvPlain3andSUSD",
         type: tokenType_1.TokenType.CURVE_LP,
+        pool: "CURVE_SUSD_POOL",
+        wrapper: "CURVE_SUSD_DEPOSIT",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.CurveWithdrawLP,
@@ -86,6 +90,7 @@ exports.curveTokens = {
         decimals: 18,
         symbol: "FRAX3CRV",
         type: tokenType_1.TokenType.META_CURVE_LP,
+        pool: "CURVE_FRAX_POOL",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.CurveWithdrawLP,
@@ -109,6 +114,7 @@ exports.curveTokens = {
         decimals: 18,
         symbol: "LUSD3CRV",
         type: tokenType_1.TokenType.META_CURVE_LP,
+        pool: "CURVE_LUSD_POOL",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.CurveWithdrawLP,
@@ -122,6 +128,7 @@ exports.curveTokens = {
         decimals: 18,
         symbol: "gusd3CRV",
         type: tokenType_1.TokenType.META_CURVE_LP,
+        pool: "CURVE_GUSD_POOL",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.CurveWithdrawLP,

package/lib/tokens/gear.d.ts

@@ -1,5 +1,5 @@
-import { TokenBase } from "./token";
-import { TradeAction } from "../pathfinder/tradeTypes";
+import type { TokenBase } from "./token";
+import type { TradeAction } from "../pathfinder/tradeTypes";
 import { TokenType } from "./tokenType";
 export declare type DieselTokenTypes = "dDAI" | "dUSDC" | "dWBTC" | "dWETH";
 export declare type GearboxToken = "GEAR";

package/lib/tokens/gear.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.gearTokens = void 0;
 var tokenType_1 = require("./tokenType");
 exports.gearTokens = {
-    //GEARBOX
+    // GEARBOX
     dDAI: {
         name: "dDAI",
         decimals: 18,

package/lib/tokens/normal.d.ts

@@ -1,5 +1,5 @@
 import { TradeAction } from "../pathfinder/tradeTypes";
-import { TokenBase } from "./token";
+import type { TokenBase } from "./token";
 import { TokenType } from "./tokenType";
 export declare type NormalToken = "1INCH" | "AAVE" | "COMP" | "CRV" | "DPI" | "FEI" | "LINK" | "SNX" | "SUSHI" | "UNI" | "USDT" | "USDC" | "DAI" | "WETH" | "WBTC" | "YFI" | "STETH" | "FTM" | "CVX" | "FRAX" | "FXS" | "LDO" | "SPELL" | "LUSD" | "sUSD" | "GUSD" | "LUNA" | "LQTY";
 export declare type NormalTokenData = {