@gearbox-protocol/sdk 0.0.103 → 0.0.104

package/.eslintignore

@@ -1,4 +1,5 @@
 node_modules
+lib
 src/types
 .eslintrc.js
 *.d.ts

package/lib/contracts/contracts.d.ts

@@ -1,9 +1,10 @@
+import type { YearnLPToken } from "src/tokens/yearn";
 import { AdapterInterface } from "./adapters";
 import { NetworkType } from "../core/constants";
 import { Protocols } from "./protocols";
-import type { ConvexStakedPhantomToken } from "../tokens/convex";
+import { ConvexStakedPhantomToken } from "../tokens/convex";
 import type { CurveLPToken } from "../tokens/curveLP";
-import type { NormalToken } from "../tokens/normal";
+import { NormalToken } from "../tokens/normal";
 export declare type UniswapV2Contract = "UNISWAP_V2_ROUTER" | "SUSHISWAP_ROUTER";
 export declare type CurvePoolContract = "CURVE_3CRV_POOL" | "CURVE_STETH_GATEWAY" | "CURVE_FRAX_POOL" | "CURVE_LUSD_POOL" | "CURVE_GUSD_POOL" | "CURVE_SUSD_POOL" | "CURVE_SUSD_DEPOSIT";
 export declare type YearnVaultContract = "YEARN_DAI_VAULT" | "YEARN_USDC_VAULT" | "YEARN_WETH_VAULT" | "YEARN_WBTC_VAULT" | "YEARN_CURVE_FRAX_VAULT" | "YEARN_CURVE_STETH_VAULT";
@@ -34,11 +35,13 @@ export declare type CurveSteCRVPoolParams = {
     protocol: Protocols.Curve;
     type: AdapterInterface.CURVE_V1_STECRV_POOL;
     pool: Record<NetworkType, string>;
+    tokens: ["WETH", "STETH"];
     lpToken: "steCRV";
 } & BaseContractParams;
-declare type YearnParams = {
+export declare type YearnParams = {
     protocol: Protocols.Yearn;
     type: AdapterInterface.YEARN_V2;
+    shareToken: YearnLPToken;
 } & BaseContractParams;
 declare type ConvexParams = {
     protocol: Protocols.Convex;

package/lib/contracts/contracts.js

@@ -12,11 +12,6 @@ var __assign = (this && this.__assign) || function () {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.contractsByAddress = exports.contractParams = exports.UNISWAP_V3_QUOTER = exports.contractsByNetwork = void 0;
-/*
- * SPDX-License-Identifier: BSL-1.1
- * Gearbox. Generalized leverage protocol, which allows to take leverage and then use it across other DeFi protocols and platforms in a composable way.
- * (c) Gearbox.fi, 2021
- */
 var mappers_1 = require("../utils/mappers");
 var adapters_1 = require("./adapters");
 var protocols_1 = require("./protocols");
@@ -123,6 +118,7 @@ exports.contractParams = {
             Mainnet: "0xDC24316b9AE028F1497c275EB9192a3Ea0f67022",
             Kovan: "0xF5C73b58B70709e89aA1D322d48b0D0C71123cB4"
         },
+        tokens: ["WETH", "STETH"],
         lpToken: "steCRV"
     },
     CURVE_FRAX_POOL: {
@@ -130,14 +126,14 @@ exports.contractParams = {
         protocol: protocols_1.Protocols.Curve,
         type: adapters_1.AdapterInterface.CURVE_V1_2ASSETS,
         lpToken: "FRAX3CRV",
-        tokens: ["3Crv", "FRAX"]
+        tokens: ["FRAX", "3Crv"]
     },
     CURVE_LUSD_POOL: {
         name: "Curve LUSD",
         protocol: protocols_1.Protocols.Curve,
         type: adapters_1.AdapterInterface.CURVE_V1_2ASSETS,
         lpToken: "LUSD3CRV",
-        tokens: ["3Crv", "LUSD"]
+        tokens: ["LUSD", "3Crv"]
     },
     CURVE_SUSD_POOL: {
         name: "Curve SUSD",
@@ -152,45 +148,50 @@ exports.contractParams = {
         protocol: protocols_1.Protocols.Curve,
         type: adapters_1.AdapterInterface.CURVE_V1_WRAPPER,
         lpToken: "crvPlain3andSUSD",
-        tokens: ["DAI", "USDC", "USDT", "sUSD"],
-        wrapper: "CURVE_SUSD_DEPOSIT"
+        tokens: ["DAI", "USDC", "USDT", "sUSD"]
     },
     CURVE_GUSD_POOL: {
         name: "Curve GUSD",
         protocol: protocols_1.Protocols.Curve,
         type: adapters_1.AdapterInterface.CURVE_V1_2ASSETS,
         lpToken: "gusd3CRV",
-        tokens: ["3Crv", "FRAX"]
+        tokens: ["GUSD", "3Crv"]
     },
     YEARN_DAI_VAULT: {
         name: "Yearn DAI",
         protocol: protocols_1.Protocols.Yearn,
-        type: adapters_1.AdapterInterface.YEARN_V2
+        type: adapters_1.AdapterInterface.YEARN_V2,
+        shareToken: "yvDAI"
     },
     YEARN_USDC_VAULT: {
         name: "Yearn USDC",
         protocol: protocols_1.Protocols.Yearn,
-        type: adapters_1.AdapterInterface.YEARN_V2
+        type: adapters_1.AdapterInterface.YEARN_V2,
+        shareToken: "yvUSDC"
     },
     YEARN_WETH_VAULT: {
         name: "Yearn WETH",
         protocol: protocols_1.Protocols.Yearn,
-        type: adapters_1.AdapterInterface.YEARN_V2
+        type: adapters_1.AdapterInterface.YEARN_V2,
+        shareToken: "yvWETH"
     },
     YEARN_WBTC_VAULT: {
         name: "Yearn WBTC",
         protocol: protocols_1.Protocols.Yearn,
-        type: adapters_1.AdapterInterface.YEARN_V2
+        type: adapters_1.AdapterInterface.YEARN_V2,
+        shareToken: "yvWBTC"
     },
     YEARN_CURVE_FRAX_VAULT: {
         name: "Yearn Curve FRAX",
         protocol: protocols_1.Protocols.Yearn,
-        type: adapters_1.AdapterInterface.YEARN_V2
+        type: adapters_1.AdapterInterface.YEARN_V2,
+        shareToken: "yvCurve_FRAX"
     },
     YEARN_CURVE_STETH_VAULT: {
         name: "Yearn Curve STETH",
         protocol: protocols_1.Protocols.Yearn,
-        type: adapters_1.AdapterInterface.YEARN_V2
+        type: adapters_1.AdapterInterface.YEARN_V2,
+        shareToken: "yvCurve_stETH"
     },
     CONVEX_BOOSTER: {
         name: "Convex BOOSTER",

package/lib/index.d.ts

@@ -42,6 +42,13 @@ export * from "./core/history";
 export * from "./utils/multicall";
 export * from "./utils/types";
 export * from "./utils/errors";
+export * from "./strategies/convex";
+export * from "./strategies/creditFacade";
+export * from "./strategies/curve";
+export * from "./strategies/lido";
+export * from "./strategies/uniswapV2";
+export * from "./strategies/uniswapV3";
+export * from "./strategies/yearn";
 export { callRepeater } from "./utils/repeater";
 export { getContractName } from "./contracts/contractsRegister";
 export { AdapterInterface } from "./contracts/adapters";

package/lib/index.js

@@ -61,6 +61,13 @@ __exportStar(require("./core/history"), exports);
 __exportStar(require("./utils/multicall"), exports);
 __exportStar(require("./utils/types"), exports);
 __exportStar(require("./utils/errors"), exports);
+__exportStar(require("./strategies/convex"), exports);
+__exportStar(require("./strategies/creditFacade"), exports);
+__exportStar(require("./strategies/curve"), exports);
+__exportStar(require("./strategies/lido"), exports);
+__exportStar(require("./strategies/uniswapV2"), exports);
+__exportStar(require("./strategies/uniswapV3"), exports);
+__exportStar(require("./strategies/yearn"), exports);
 var repeater_1 = require("./utils/repeater");
 Object.defineProperty(exports, "callRepeater", { enumerable: true, get: function () { return repeater_1.callRepeater; } });
 var contractsRegister_1 = require("./contracts/contractsRegister");

package/lib/strategies/convex.d.ts

@@ -1,4 +1,7 @@
 import { BigNumberish } from "ethers";
+import { ConvexPoolContract } 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 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("src/contracts/contracts");
+var token_1 = require("src/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 "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;
@@ -15,6 +18,7 @@ export declare class CurveCalls {
 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;
@@ -32,3 +36,8 @@ export declare class CurveMulticaller {
     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() {
     }
@@ -69,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,
@@ -132,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

@@ -21,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

@@ -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,7 +1,22 @@
 "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() {
     }
@@ -43,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,
@@ -58,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;