@gearbox-protocol/sdk 0.0.102 → 0.0.105

package/src/strategies/yearn.ts

@@ -1,77 +1,204 @@
-import { BigNumberish } from "ethers"
-
-
+import { BigNumberish } from "ethers";
 import {
-    YearnV2Adapter__factory
-} from "../types"
+  contractParams,
+  contractsByNetwork,
+  YearnParams,
+  YearnVaultContract
+} from "../contracts/contracts";
+import { ADDRESS_0X0, NetworkType } from "../core/constants";
+import { CreditManagerData } from "../core/creditManager";
+import { CurveLPTokenData } from "../tokens/curveLP";
+import { supportedTokens, tokenDataByNetwork } from "../tokens/token";
+import { TokenType } from "../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 {
-        let contractInterface = YearnV2Adapter__factory.createInterface();
-        if (amount && recipient) {
-            return contractInterface.encodeFunctionData(
-                "deposit(uint256,address)",
-                [amount, recipient]
-            );
-        } else if (amount) {
-            return contractInterface.encodeFunctionData(
-                "deposit(uint256)",
-                [amount]
-            );
-        } else {
-            return contractInterface.encodeFunctionData(
-                "deposit()"
-            );
-        }
+  public static deposit(amount?: BigNumberish, recipient?: string): string {
+    const contractInterface = YearnV2Adapter__factory.createInterface();
+    if (amount && recipient) {
+      return contractInterface.encodeFunctionData("deposit(uint256,address)", [
+        amount,
+        recipient
+      ]);
+    }
+    if (amount) {
+      return contractInterface.encodeFunctionData("deposit(uint256)", [amount]);
     }
+    return contractInterface.encodeFunctionData("deposit()");
+  }
 
-    public static withdraw(maxShares?: BigNumberish, recipient?: string, maxLoss?: BigNumberish): string {
-        let contractInterface = YearnV2Adapter__factory.createInterface();
-        if (maxShares && recipient && maxLoss) {
-            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]
-            );
-        } else {
-            return contractInterface.encodeFunctionData(
-                "withdraw()"
-            );
-        }
+  public static withdraw(
+    maxShares?: BigNumberish,
+    recipient?: string,
+    maxLoss?: BigNumberish
+  ): string {
+    const contractInterface = YearnV2Adapter__factory.createInterface();
+    if (maxShares && recipient && maxLoss) {
+      return contractInterface.encodeFunctionData(
+        "withdraw(uint256,address,uint256)",
+        [maxShares, recipient, maxLoss]
+      );
     }
+    if (maxShares && recipient) {
+      return contractInterface.encodeFunctionData("withdraw(uint256,address)", [
+        maxShares,
+        recipient
+      ]);
+    }
+    if (maxShares) {
+      return contractInterface.encodeFunctionData("withdraw(uint256)", [
+        maxShares
+      ]);
+    }
+    return contractInterface.encodeFunctionData("withdraw()");
+  }
 }
 
 export class YearnV2Multicaller {
-    private readonly _address: string;
+  private readonly _address: string;
 
-    constructor(address: string) {
-        this._address = address;
-    }
+  constructor(address: string) {
+    this._address = address;
+  }
+
+  static connect(address: string) {
+    return new YearnV2Multicaller(address);
+  }
 
-    deposit(amount?: BigNumberish, recipient?: string): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: YearnV2Calls.deposit(amount, recipient)
-        };
+  deposit(amount?: BigNumberish, recipient?: string): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: YearnV2Calls.deposit(amount, recipient)
+    };
+  }
+
+  withdraw(
+    maxShares?: BigNumberish,
+    recipient?: string,
+    maxLoss?: BigNumberish
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: YearnV2Calls.withdraw(maxShares, recipient, maxLoss)
+    };
+  }
+}
+
+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");
     }
 
-    withdraw(maxShares?: BigNumberish, recipient?: string, maxLoss?: BigNumberish): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: YearnV2Calls.withdraw(maxShares, recipient, maxLoss)
-        };
+    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/connectors.ts

@@ -1,8 +1,8 @@
-import {NormalToken} from "./normal";
+import { NormalToken } from "./normal";
 
 export const connectorTokens: Array<NormalToken> = [
-    "DAI",
-    "USDC",
-    "WETH",
-    "WBTC"
-];
+  "DAI",
+  "USDC",
+  "WETH",
+  "WBTC"
+];