@gearbox-protocol/sdk 0.0.103 → 0.0.104

package/lib/tokens/curveLP.d.ts

@@ -1,4 +1,5 @@
 import { BigNumber } from "ethers";
+import type { CurvePoolContract } from "src/contracts/contracts";
 import { TradeAction } from "../pathfinder/tradeTypes";
 import type { SupportedToken, TokenBase } from "./token";
 import { PartialRecord } from "../utils/types";
@@ -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

@@ -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/yearn.d.ts

@@ -1,7 +1,8 @@
+import type { YearnVaultContract } from "src/contracts/contracts";
 import { TradeAction } from "../pathfinder/tradeTypes";
 import type { TokenBase } from "./token";
 import type { CurveLPToken } from "./curveLP";
-import type { NormalToken } from "./normal";
+import { NormalToken } from "./normal";
 import { TokenType } from "./tokenType";
 export declare type YearnLPToken = "yvDAI" | "yvUSDC" | "yvWETH" | "yvWBTC" | "yvCurve_stETH" | "yvCurve_FRAX";
 export declare type YearnVaultTokenData = {
@@ -9,17 +10,20 @@ export declare type YearnVaultTokenData = {
     type: TokenType.YEARN_VAULT;
     underlying: NormalToken;
     lpActions: Array<TradeAction>;
+    vault: YearnVaultContract;
 } & TokenBase;
 export declare type YearnVaultOfCurveLPTokenData = {
     symbol: YearnLPToken;
     type: TokenType.YEARN_VAULT_OF_CURVE_LP;
     underlying: CurveLPToken;
     lpActions: Array<TradeAction>;
+    vault: YearnVaultContract;
 } & TokenBase;
 export declare type YearnVaultOfMetaCurveLPTokenData = {
     symbol: YearnLPToken;
     type: TokenType.YEARN_VAULT_OF_META_CURVE_LP;
     underlying: CurveLPToken;
     lpActions: Array<TradeAction>;
+    vault: YearnVaultContract;
 } & TokenBase;
 export declare const yearnTokens: Record<YearnLPToken, YearnVaultTokenData | YearnVaultOfCurveLPTokenData | YearnVaultOfMetaCurveLPTokenData>;

package/lib/tokens/yearn.js

@@ -11,6 +11,7 @@ exports.yearnTokens = {
         symbol: "yvDAI",
         type: tokenType_1.TokenType.YEARN_VAULT,
         underlying: "DAI",
+        vault: "YEARN_DAI_VAULT",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.YearnWithdraw,
@@ -25,6 +26,7 @@ exports.yearnTokens = {
         symbol: "yvUSDC",
         type: tokenType_1.TokenType.YEARN_VAULT,
         underlying: "USDC",
+        vault: "YEARN_USDC_VAULT",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.YearnWithdraw,
@@ -39,6 +41,7 @@ exports.yearnTokens = {
         symbol: "yvWETH",
         type: tokenType_1.TokenType.YEARN_VAULT,
         underlying: "WETH",
+        vault: "YEARN_WETH_VAULT",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.YearnWithdraw,
@@ -53,6 +56,7 @@ exports.yearnTokens = {
         symbol: "yvWBTC",
         type: tokenType_1.TokenType.YEARN_VAULT,
         underlying: "WBTC",
+        vault: "YEARN_WBTC_VAULT",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.YearnWithdraw,
@@ -68,6 +72,7 @@ exports.yearnTokens = {
         symbol: "yvCurve_stETH",
         type: tokenType_1.TokenType.YEARN_VAULT_OF_CURVE_LP,
         underlying: "steCRV",
+        vault: "YEARN_CURVE_STETH_VAULT",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.YearnWithdraw,
@@ -82,6 +87,7 @@ exports.yearnTokens = {
         symbol: "yvCurve_FRAX",
         type: tokenType_1.TokenType.YEARN_VAULT_OF_META_CURVE_LP,
         underlying: "FRAX3CRV",
+        vault: "YEARN_CURVE_FRAX_VAULT",
         lpActions: [
             {
                 type: tradeTypes_1.TradeType.YearnWithdraw,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "0.0.103",
+  "version": "0.0.104",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -16,8 +16,7 @@
   },
   "dependencies": {
     "decimal.js-light": "^2.5.1",
-    "moment": "^2.29.1",
-    "prettier": "^2.7.1"
+    "moment": "^2.29.1"
   },
   "devDependencies": {
     "@types/jest": "^26.0.15",

package/src/contracts/contracts.ts

@@ -3,6 +3,7 @@
  * 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
  */
+import type { YearnLPToken } from "src/tokens/yearn";
 import {
   keyToLowercase,
   objectEntries,
@@ -13,9 +14,9 @@ import { AdapterInterface } from "./adapters";
 import { NetworkType } from "../core/constants";
 import { Protocols } from "./protocols";
 import { tokenDataByNetwork } from "../tokens/token";
-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 type UniswapV2Contract = "UNISWAP_V2_ROUTER" | "SUSHISWAP_ROUTER";
 
@@ -169,12 +170,14 @@ export type CurveSteCRVPoolParams = {
   protocol: Protocols.Curve;
   type: AdapterInterface.CURVE_V1_STECRV_POOL;
   pool: Record<NetworkType, string>;
+  tokens: ["WETH", "STETH"];
   lpToken: "steCRV";
 } & BaseContractParams;
 
-type YearnParams = {
+export type YearnParams = {
   protocol: Protocols.Yearn;
   type: AdapterInterface.YEARN_V2;
+  shareToken: YearnLPToken;
 } & BaseContractParams;
 
 type ConvexParams = {
@@ -247,6 +250,7 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
       Mainnet: "0xDC24316b9AE028F1497c275EB9192a3Ea0f67022",
       Kovan: "0xF5C73b58B70709e89aA1D322d48b0D0C71123cB4"
     },
+    tokens: ["WETH", "STETH"],
     lpToken: "steCRV"
   },
   CURVE_FRAX_POOL: {
@@ -254,14 +258,14 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "FRAX3CRV",
-    tokens: ["3Crv", "FRAX"]
+    tokens: ["FRAX", "3Crv"]
   },
   CURVE_LUSD_POOL: {
     name: "Curve LUSD",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "LUSD3CRV",
-    tokens: ["3Crv", "LUSD"]
+    tokens: ["LUSD", "3Crv"]
   },
   CURVE_SUSD_POOL: {
     name: "Curve SUSD",
@@ -277,8 +281,7 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_WRAPPER,
     lpToken: "crvPlain3andSUSD",
-    tokens: ["DAI", "USDC", "USDT", "sUSD"],
-    wrapper: "CURVE_SUSD_DEPOSIT"
+    tokens: ["DAI", "USDC", "USDT", "sUSD"]
   },
 
   CURVE_GUSD_POOL: {
@@ -286,38 +289,44 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "gusd3CRV",
-    tokens: ["3Crv", "FRAX"]
+    tokens: ["GUSD", "3Crv"]
   },
 
   YEARN_DAI_VAULT: {
     name: "Yearn DAI",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvDAI"
   },
   YEARN_USDC_VAULT: {
     name: "Yearn USDC",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvUSDC"
   },
   YEARN_WETH_VAULT: {
     name: "Yearn WETH",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvWETH"
   },
   YEARN_WBTC_VAULT: {
     name: "Yearn WBTC",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvWBTC"
   },
   YEARN_CURVE_FRAX_VAULT: {
     name: "Yearn Curve FRAX",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvCurve_FRAX"
   },
   YEARN_CURVE_STETH_VAULT: {
     name: "Yearn Curve STETH",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvCurve_stETH"
   },
 
   CONVEX_BOOSTER: {

package/src/index.ts

@@ -47,6 +47,15 @@ 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/src/strategies/convex.ts

@@ -1,4 +1,15 @@
 import { BigNumberish } from "ethers";
+import {
+  contractParams,
+  contractsByNetwork,
+  ConvexPoolContract,
+  ConvexPoolParams
+} from "src/contracts/contracts";
+import { NetworkType } from "src/core/constants";
+import { CreditManagerData } from "src/core/creditManager";
+import { ConvexPhantomTokenData } from "src/tokens/convex";
+import { CurveLPTokenData } from "src/tokens/curveLP";
+import { supportedTokens, tokenDataByNetwork } from "src/tokens/token";
 
 import {
   ConvexV1BoosterAdapter__factory,
@@ -7,6 +18,8 @@ import {
 } from "../types";
 
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
+import { CurveStrategies } from "./curve";
+import { UniswapV2Multicaller } from "./uniswapV2";
 
 export class ConvexBoosterCalls {
   public static deposit(
@@ -121,6 +134,10 @@ export class ConvexBoosterMulticaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new ConvexBoosterMulticaller(address);
+  }
+
   deposit(
     pid: BigNumberish,
     amount: BigNumberish,
@@ -161,6 +178,10 @@ export class ConvexPoolMulticaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new ConvexPoolMulticaller(address);
+  }
+
   stake(amount: BigNumberish): MultiCallStruct {
     return {
       target: this._address,
@@ -211,6 +232,10 @@ export class ConvexClaimZapMulticaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new ConvexClaimZapMulticaller(address);
+  }
+
   claimRewards(
     rewardContracts: Array<string>,
     extraRewardContracts: Array<string>,
@@ -238,3 +263,145 @@ export class ConvexClaimZapMulticaller {
     };
   }
 }
+
+export class ConvexStrategies {
+  static underlyingToStakedConvex(
+    data: CreditManagerData,
+    network: NetworkType,
+    convexPool: ConvexPoolContract,
+    underlyingAmount: BigNumberish
+  ) {
+    let calls: Array<MultiCallStruct> = [];
+    const convexParams = contractParams[convexPool] as ConvexPoolParams;
+    const { stakedToken } = convexParams;
+    const stakedTokenParams = supportedTokens[
+      stakedToken
+    ] as ConvexPhantomTokenData;
+    const curveLpToken = stakedTokenParams.underlying;
+    const curveLpTokenData = supportedTokens[curveLpToken] as CurveLPTokenData;
+    const curvePool = curveLpTokenData.pool;
+
+    calls = CurveStrategies.underlyingToCurveLP(
+      data,
+      network,
+      curvePool,
+      underlyingAmount
+    );
+
+    calls.push(
+      ConvexBoosterMulticaller.connect(
+        data.adapters[contractsByNetwork[network].CONVEX_BOOSTER]
+      ).depositAll(stakedTokenParams.pid, true)
+    );
+
+    return calls;
+  }
+
+  static stakedConvexToUnderlying(
+    data: CreditManagerData,
+    network: NetworkType,
+    convexPool: ConvexPoolContract,
+    convexLpAmount: BigNumberish,
+    sellRewards: boolean
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const convexParams = contractParams[convexPool] as ConvexPoolParams;
+    const { stakedToken } = convexParams;
+    const stakedTokenParams = supportedTokens[
+      stakedToken
+    ] as ConvexPhantomTokenData;
+    const curveLpToken = stakedTokenParams.underlying;
+    const curveLpTokenData = supportedTokens[curveLpToken] as CurveLPTokenData;
+    const curvePool = curveLpTokenData.pool;
+
+    calls.push(
+      ConvexPoolMulticaller.connect(
+        data.adapters[contractsByNetwork[network][convexPool]]
+      ).withdrawAndUnwrap(convexLpAmount, true)
+    );
+
+    calls.push(
+      ...CurveStrategies.allCurveLPToUnderlying(data, network, curvePool)
+    );
+
+    if (sellRewards) {
+      calls.push(...ConvexStrategies.sellRewards(data, network, convexPool));
+    }
+
+    return calls;
+  }
+
+  static allStakedConvexToUnderlying(
+    data: CreditManagerData,
+    network: NetworkType,
+    convexPool: ConvexPoolContract,
+    sellRewards: boolean
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const convexParams = contractParams[convexPool] as ConvexPoolParams;
+    const { stakedToken } = convexParams;
+    const stakedTokenParams = supportedTokens[
+      stakedToken
+    ] as ConvexPhantomTokenData;
+    const curveLpToken = stakedTokenParams.underlying;
+    const curveLpTokenData = supportedTokens[curveLpToken] as CurveLPTokenData;
+    const curvePool = curveLpTokenData.pool;
+
+    calls.push(
+      ConvexPoolMulticaller.connect(
+        data.adapters[contractsByNetwork[network][convexPool]]
+      ).withdrawAllAndUnwrap(true)
+    );
+
+    calls.push(
+      ...CurveStrategies.allCurveLPToUnderlying(data, network, curvePool)
+    );
+
+    if (sellRewards) {
+      calls.push(...ConvexStrategies.sellRewards(data, network, convexPool));
+    }
+
+    return calls;
+  }
+
+  static sellRewards(
+    data: CreditManagerData,
+    network: NetworkType,
+    convexPool: ConvexPoolContract
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const convexParams = contractParams[convexPool] as ConvexPoolParams;
+
+    calls.push(
+      UniswapV2Multicaller.connect(
+        data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+      ).swapAllTokensForTokens(
+        0,
+        [tokenDataByNetwork[network].CRV, data.underlyingToken],
+        Math.floor(new Date().getTime() / 1000) + 3600
+      ),
+      UniswapV2Multicaller.connect(
+        data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+      ).swapAllTokensForTokens(
+        0,
+        [tokenDataByNetwork[network].CVX, data.underlyingToken],
+        Math.floor(new Date().getTime() / 1000) + 3600
+      )
+    );
+
+    convexParams.extraRewards.forEach(extraReward => {
+      UniswapV2Multicaller.connect(
+        data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+      ).swapAllTokensForTokens(
+        0,
+        [
+          tokenDataByNetwork[network][extraReward.rewardToken],
+          data.underlyingToken
+        ],
+        Math.floor(new Date().getTime() / 1000) + 3600
+      );
+    });
+
+    return calls;
+  }
+}

package/src/strategies/creditFacade.ts

@@ -50,6 +50,10 @@ export class CreditFacadeMulticaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new CreditFacadeMulticaller(address);
+  }
+
   addCollateral(
     onBehalfOf: string,
     token: string,

package/src/strategies/curve.ts

@@ -1,4 +1,13 @@
 import { BigNumberish } from "ethers";
+import {
+  contractParams,
+  contractsByNetwork,
+  CurveParams,
+  CurvePoolContract
+} from "src/contracts/contracts";
+import { ADDRESS_0X0, NetworkType } from "src/core/constants";
+import { CreditManagerData } from "src/core/creditManager";
+import { tokenDataByNetwork } from "src/tokens/token";
 
 import {
   CurveV1AdapterBase__factory,
@@ -8,6 +17,7 @@ import {
 } from "../types";
 
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
+import { UniswapV2Multicaller } from "./uniswapV2";
 
 export class CurveCalls {
   public static exchange(
@@ -179,6 +189,10 @@ export class CurveMulticaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new CurveMulticaller(address);
+  }
+
   exchange(
     i: BigNumberish,
     j: BigNumberish,
@@ -296,3 +310,131 @@ export class CurveMulticaller {
     };
   }
 }
+
+export class CurveStrategies {
+  static underlyingToCurveLP(
+    data: CreditManagerData,
+    network: NetworkType,
+    curvePool: CurvePoolContract,
+    underlyingAmount: BigNumberish
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const curveParams = contractParams[curvePool] as CurveParams;
+    const tokenToDeposit = curveParams.tokens[0];
+
+    if (data.underlyingToken !== tokenDataByNetwork[network][tokenToDeposit]) {
+      calls.push(
+        UniswapV2Multicaller.connect(
+          data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+        ).swapExactTokensForTokens(
+          underlyingAmount,
+          0,
+          [data.underlyingToken, tokenDataByNetwork[network][tokenToDeposit]],
+          ADDRESS_0X0,
+          Math.floor(new Date().getTime() / 1000) + 3600
+        )
+      );
+    }
+
+    calls.push(
+      CurveMulticaller.connect(
+        data.adapters[contractsByNetwork[network][curvePool]]
+      ).add_all_liquidity_one_coin(0, 0)
+    );
+
+    return calls;
+  }
+
+  static curveLPToUnderlying(
+    data: CreditManagerData,
+    network: NetworkType,
+    curvePool: CurvePoolContract,
+    curveLPAmount: BigNumberish
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const curveParams = contractParams[curvePool] as CurveParams;
+
+    let curveContractAddress;
+
+    if (curveParams.wrapper) {
+      curveContractAddress =
+        data.adapters[contractsByNetwork[network][curveParams.wrapper]];
+    } else {
+      curveContractAddress =
+        data.adapters[contractsByNetwork[network][curvePool]];
+    }
+
+    calls.push(
+      CurveMulticaller.connect(curveContractAddress).remove_liquidity_one_coin(
+        curveLPAmount,
+        0,
+        0
+      )
+    );
+
+    if (
+      tokenDataByNetwork[network][curveParams.tokens[0]] !==
+      data.underlyingToken
+    ) {
+      calls.push(
+        UniswapV2Multicaller.connect(
+          data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+        ).swapAllTokensForTokens(
+          0,
+          [
+            tokenDataByNetwork[network][curveParams.tokens[0]],
+            data.underlyingToken
+          ],
+          Math.floor(new Date().getTime() / 1000) + 3600
+        )
+      );
+    }
+
+    return calls;
+  }
+
+  static allCurveLPToUnderlying(
+    data: CreditManagerData,
+    network: NetworkType,
+    curvePool: CurvePoolContract
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const curveParams = contractParams[curvePool] as CurveParams;
+
+    let curveContractAddress;
+
+    if (curveParams.wrapper) {
+      curveContractAddress =
+        data.adapters[contractsByNetwork[network][curveParams.wrapper]];
+    } else {
+      curveContractAddress =
+        data.adapters[contractsByNetwork[network][curvePool]];
+    }
+
+    calls.push(
+      CurveMulticaller.connect(
+        curveContractAddress
+      ).remove_all_liquidity_one_coin(0, 0)
+    );
+
+    if (
+      tokenDataByNetwork[network][curveParams.tokens[0]] !==
+      data.underlyingToken
+    ) {
+      calls.push(
+        UniswapV2Multicaller.connect(
+          data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+        ).swapAllTokensForTokens(
+          0,
+          [
+            tokenDataByNetwork[network][curveParams.tokens[0]],
+            data.underlyingToken
+          ],
+          Math.floor(new Date().getTime() / 1000) + 3600
+        )
+      );
+    }
+
+    return calls;
+  }
+}