@gearbox-protocol/sdk 0.0.103 → 0.0.104

package/src/strategies/lido.ts

@@ -1,8 +1,13 @@
 import { BigNumberish } from "ethers";
+import { CreditManagerData } from "src/core/creditManager";
+import { ADDRESS_0X0, NetworkType } from "src/core/constants";
 
+import { contractsByNetwork } from "src/contracts/contracts";
+import { tokenDataByNetwork } from "src/tokens/token";
 import { LidoV1Adapter__factory } from "../types";
 
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
+import { UniswapV2Multicaller } from "./uniswapV2";
 
 export class LidoCalls {
   public static submit(amount: BigNumberish) {
@@ -26,6 +31,10 @@ export class LidoMulticaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new LidoMulticaller(address);
+  }
+
   submit(amount: BigNumberish): MultiCallStruct {
     return {
       target: this._address,
@@ -40,3 +49,36 @@ export class LidoMulticaller {
     };
   }
 }
+
+export class LidoStrategies {
+  static mintSteth(
+    data: CreditManagerData,
+    network: NetworkType,
+    underlyingAmount: BigNumberish
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+
+    // This should be a pathfinder call
+    if (!data.isWETH) {
+      calls.push(
+        UniswapV2Multicaller.connect(
+          data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+        ).swapExactTokensForTokens(
+          underlyingAmount,
+          0,
+          [data.underlyingToken, tokenDataByNetwork[network].WETH],
+          ADDRESS_0X0,
+          Math.floor(new Date().getTime() / 1000) + 3600
+        )
+      );
+    }
+
+    calls.push(
+      LidoMulticaller.connect(
+        data.adapters[contractsByNetwork[network].LIDO_STETH_GATEWAY]
+      ).submitAll()
+    );
+
+    return calls;
+  }
+}

package/src/strategies/uniswapV2.ts

@@ -50,6 +50,10 @@ export class UniswapV2Multicaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new UniswapV2Multicaller(address);
+  }
+
   swapExactTokensForTokens(
     amountIn: BigNumberish,
     amountOutMin: BigNumberish,

package/src/strategies/uniswapV3.ts

@@ -67,6 +67,10 @@ export class UniswapV3Multicaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new UniswapV3Multicaller(address);
+  }
+
   exactInputSingle(
     params: ISwapRouter.ExactInputSingleParamsStructOutput
   ): MultiCallStruct {

package/src/strategies/yearn.ts

@@ -1,8 +1,21 @@
 import { BigNumberish } from "ethers";
+import {
+  contractParams,
+  contractsByNetwork,
+  YearnParams,
+  YearnVaultContract
+} from "src/contracts/contracts";
+import { ADDRESS_0X0, NetworkType } from "src/core/constants";
+import { CreditManagerData } from "src/core/creditManager";
+import { CurveLPTokenData } from "src/tokens/curveLP";
+import { supportedTokens, tokenDataByNetwork } from "src/tokens/token";
+import { TokenType } from "src/tokens/tokenType";
 
 import { YearnV2Adapter__factory } from "../types";
 
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
+import { CurveStrategies } from "./curve";
+import { UniswapV2Multicaller } from "./uniswapV2";
 
 export class YearnV2Calls {
   public static deposit(amount?: BigNumberish, recipient?: string): string {
@@ -53,6 +66,10 @@ export class YearnV2Multicaller {
     this._address = address;
   }
 
+  static connect(address: string) {
+    return new YearnV2Multicaller(address);
+  }
+
   deposit(amount?: BigNumberish, recipient?: string): MultiCallStruct {
     return {
       target: this._address,
@@ -71,3 +88,117 @@ export class YearnV2Multicaller {
     };
   }
 }
+
+export class YearnV2Strategies {
+  static underlyingToYearn(
+    data: CreditManagerData,
+    network: NetworkType,
+    yearnVault: YearnVaultContract,
+    underlyingAmount: BigNumberish
+  ) {
+    let calls: Array<MultiCallStruct> = [];
+    const vaultParams = contractParams[yearnVault] as YearnParams;
+    const yearnToken = vaultParams.shareToken;
+    const yearnParams = supportedTokens[yearnToken];
+
+    if (yearnParams.type === TokenType.YEARN_VAULT) {
+      if (
+        data.underlyingToken !==
+        tokenDataByNetwork[network][yearnParams.underlying]
+      ) {
+        // This should be a pathfinder call
+        calls.push(
+          UniswapV2Multicaller.connect(
+            data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+          ).swapExactTokensForTokens(
+            underlyingAmount,
+            0,
+            [
+              data.underlyingToken,
+              tokenDataByNetwork[network][yearnParams.underlying]
+            ],
+            ADDRESS_0X0,
+            Math.floor(new Date().getTime() / 1000) + 3600
+          )
+        );
+      }
+    } else if (
+      yearnParams.type === TokenType.YEARN_VAULT_OF_CURVE_LP ||
+      yearnParams.type === TokenType.YEARN_VAULT_OF_META_CURVE_LP
+    ) {
+      const curveTokenParams = supportedTokens[
+        yearnParams.underlying
+      ] as CurveLPTokenData;
+      const curvePool = curveTokenParams.pool;
+
+      calls = CurveStrategies.underlyingToCurveLP(
+        data,
+        network,
+        curvePool,
+        underlyingAmount
+      );
+    } else {
+      throw new Error("Yearn vault type unknown");
+    }
+
+    calls.push(
+      YearnV2Multicaller.connect(
+        data.adapters[contractsByNetwork[network][yearnVault]]
+      ).deposit()
+    );
+  }
+
+  static yearnToUnderlying(
+    data: CreditManagerData,
+    network: NetworkType,
+    yearnVault: YearnVaultContract,
+    yearnSharesAmount: BigNumberish
+  ) {
+    let calls: Array<MultiCallStruct> = [];
+    const vaultParams = contractParams[yearnVault] as YearnParams;
+    const yearnToken = vaultParams.shareToken;
+    const yearnParams = supportedTokens[yearnToken];
+
+    calls.push(
+      YearnV2Multicaller.connect(
+        data.adapters[contractsByNetwork[network][yearnVault]]
+      ).withdraw(yearnSharesAmount)
+    );
+
+    if (yearnParams.type === TokenType.YEARN_VAULT) {
+      if (
+        data.underlyingToken !==
+        tokenDataByNetwork[network][yearnParams.underlying]
+      ) {
+        // This should be a pathfinder call
+        calls.push(
+          UniswapV2Multicaller.connect(
+            data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+          ).swapAllTokensForTokens(
+            0,
+            [
+              tokenDataByNetwork[network][yearnParams.underlying],
+              data.underlyingToken
+            ],
+            Math.floor(new Date().getTime() / 1000) + 3600
+          )
+        );
+      }
+    } else if (
+      yearnParams.type === TokenType.YEARN_VAULT_OF_CURVE_LP ||
+      yearnParams.type === TokenType.YEARN_VAULT_OF_META_CURVE_LP
+    ) {
+      const curveTokenParams = supportedTokens[
+        yearnParams.underlying
+      ] as CurveLPTokenData;
+      const curvePool = curveTokenParams.pool;
+
+      calls = [
+        ...calls,
+        ...CurveStrategies.allCurveLPToUnderlying(data, network, curvePool)
+      ];
+    } else {
+      throw new Error("Yearn vault type unknown");
+    }
+  }
+}

package/src/tokens/curveLP.ts

@@ -1,4 +1,5 @@
 import { BigNumber } from "ethers";
+import type { CurvePoolContract } from "src/contracts/contracts";
 import { TradeAction, TradeType } from "../pathfinder/tradeTypes";
 import type { SupportedToken, TokenBase } from "./token";
 import { PartialRecord } from "../utils/types";
@@ -17,12 +18,16 @@ export type CurveLPTokenData = {
   type: TokenType.CURVE_LP;
   swapActions?: Array<TradeAction>;
   lpActions: Array<TradeAction>;
+  pool: CurvePoolContract;
+  wrapper?: CurvePoolContract;
 } & TokenBase;
 
 export type MetaCurveLPTokenData = {
   symbol: CurveLPToken;
   type: TokenType.META_CURVE_LP;
   lpActions: Array<TradeAction>;
+  pool: CurvePoolContract;
+  wrapper?: CurvePoolContract;
 } & TokenBase;
 
 export const Curve3CrvUnderlyingTokenIndex: PartialRecord<
@@ -42,9 +47,9 @@ export const curveTokens: Record<
   "3Crv": {
     name: "3Crv",
     decimals: 18,
-
     symbol: "3Crv",
     type: TokenType.CURVE_LP,
+    pool: "CURVE_3CRV_POOL",
     lpActions: [
       {
         type: TradeType.CurveWithdrawLP,
@@ -67,9 +72,9 @@ export const curveTokens: Record<
   steCRV: {
     name: "steCRV",
     decimals: 18,
-
     symbol: "steCRV",
     type: TokenType.CURVE_LP,
+    pool: "CURVE_STETH_GATEWAY",
     lpActions: [
       {
         type: TradeType.CurveWithdrawLP,
@@ -92,9 +97,10 @@ export const curveTokens: Record<
   crvPlain3andSUSD: {
     name: "crvPlain3andSUSD",
     decimals: 18,
-
     symbol: "crvPlain3andSUSD",
     type: TokenType.CURVE_LP,
+    pool: "CURVE_SUSD_POOL",
+    wrapper: "CURVE_SUSD_DEPOSIT",
     lpActions: [
       {
         type: TradeType.CurveWithdrawLP,
@@ -118,9 +124,9 @@ export const curveTokens: Record<
   FRAX3CRV: {
     name: "FRAX3CRV-f",
     decimals: 18,
-
     symbol: "FRAX3CRV",
     type: TokenType.META_CURVE_LP,
+    pool: "CURVE_FRAX_POOL",
     lpActions: [
       {
         type: TradeType.CurveWithdrawLP,
@@ -143,9 +149,9 @@ export const curveTokens: Record<
   LUSD3CRV: {
     name: "LUSD3CRV-f",
     decimals: 18,
-
     symbol: "LUSD3CRV",
     type: TokenType.META_CURVE_LP,
+    pool: "CURVE_LUSD_POOL",
     lpActions: [
       {
         type: TradeType.CurveWithdrawLP,
@@ -158,9 +164,9 @@ export const curveTokens: Record<
   gusd3CRV: {
     name: "gusd3CRV",
     decimals: 18,
-
     symbol: "gusd3CRV",
     type: TokenType.META_CURVE_LP,
+    pool: "CURVE_GUSD_POOL",
     lpActions: [
       {
         type: TradeType.CurveWithdrawLP,

package/src/tokens/yearn.ts

@@ -1,7 +1,8 @@
+import type { YearnVaultContract } from "src/contracts/contracts";
 import { TradeAction, TradeType } 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 type YearnLPToken =
@@ -17,6 +18,7 @@ export type YearnVaultTokenData = {
   type: TokenType.YEARN_VAULT;
   underlying: NormalToken;
   lpActions: Array<TradeAction>;
+  vault: YearnVaultContract;
 } & TokenBase;
 
 export type YearnVaultOfCurveLPTokenData = {
@@ -24,6 +26,7 @@ export type YearnVaultOfCurveLPTokenData = {
   type: TokenType.YEARN_VAULT_OF_CURVE_LP;
   underlying: CurveLPToken;
   lpActions: Array<TradeAction>;
+  vault: YearnVaultContract;
 } & TokenBase;
 
 export type YearnVaultOfMetaCurveLPTokenData = {
@@ -31,6 +34,7 @@ export type YearnVaultOfMetaCurveLPTokenData = {
   type: TokenType.YEARN_VAULT_OF_META_CURVE_LP;
   underlying: CurveLPToken;
   lpActions: Array<TradeAction>;
+  vault: YearnVaultContract;
 } & TokenBase;
 
 export const yearnTokens: Record<
@@ -43,10 +47,10 @@ export const yearnTokens: Record<
   yvDAI: {
     name: "yvDAI",
     decimals: 18,
-
     symbol: "yvDAI",
     type: TokenType.YEARN_VAULT,
     underlying: "DAI",
+    vault: "YEARN_DAI_VAULT",
     lpActions: [
       {
         type: TradeType.YearnWithdraw,
@@ -59,10 +63,10 @@ export const yearnTokens: Record<
   yvUSDC: {
     name: "yvUSDC",
     decimals: 6,
-
     symbol: "yvUSDC",
     type: TokenType.YEARN_VAULT,
     underlying: "USDC",
+    vault: "YEARN_USDC_VAULT",
     lpActions: [
       {
         type: TradeType.YearnWithdraw,
@@ -75,10 +79,10 @@ export const yearnTokens: Record<
   yvWETH: {
     name: "yvWETH",
     decimals: 18,
-
     symbol: "yvWETH",
     type: TokenType.YEARN_VAULT,
     underlying: "WETH",
+    vault: "YEARN_WETH_VAULT",
     lpActions: [
       {
         type: TradeType.YearnWithdraw,
@@ -91,10 +95,10 @@ export const yearnTokens: Record<
   yvWBTC: {
     name: "yvWBTC",
     decimals: 8,
-
     symbol: "yvWBTC",
     type: TokenType.YEARN_VAULT,
     underlying: "WBTC",
+    vault: "YEARN_WBTC_VAULT",
     lpActions: [
       {
         type: TradeType.YearnWithdraw,
@@ -108,10 +112,10 @@ export const yearnTokens: Record<
   yvCurve_stETH: {
     name: "yvCurve-stETH",
     decimals: 18,
-
     symbol: "yvCurve_stETH",
     type: TokenType.YEARN_VAULT_OF_CURVE_LP,
     underlying: "steCRV",
+    vault: "YEARN_CURVE_STETH_VAULT",
     lpActions: [
       {
         type: TradeType.YearnWithdraw,
@@ -124,10 +128,10 @@ export const yearnTokens: Record<
   yvCurve_FRAX: {
     name: "yvCurve-FRAX",
     decimals: 18,
-
     symbol: "yvCurve_FRAX",
     type: TokenType.YEARN_VAULT_OF_META_CURVE_LP,
     underlying: "FRAX3CRV",
+    vault: "YEARN_CURVE_FRAX_VAULT",
     lpActions: [
       {
         type: TradeType.YearnWithdraw,