@gearbox-protocol/sdk 0.0.39 → 0.0.42

package/src/core/protocols.ts

@@ -0,0 +1,40 @@
+export enum Protocols {
+  Uniswap,
+  Sushiswap,
+  Curve,
+  Yearn,
+  Convex,
+  Lido
+}
+
+export interface ProtocolData {
+  name: string;
+  icon: string;
+}
+
+export const protocolData: Record<Protocols, ProtocolData> = {
+  [Protocols.Uniswap]: {
+    name: "Uniswap",
+    icon: "/protocols/uniswap.png"
+  },
+  [Protocols.Sushiswap]: {
+    name: "Sushiswap",
+    icon: "/protocols/sushi.svg"
+  },
+  [Protocols.Curve]: {
+    name: "Curve",
+    icon: "/protocols/curve.svg"
+  },
+  [Protocols.Yearn]: {
+    name: "Yearn",
+    icon: "/protocols/yearn.svg"
+  },
+  [Protocols.Convex]: {
+    name: "Convex",
+    icon: "/protocols/convex.svg"
+  },
+  [Protocols.Lido]: {
+    name: "Lido",
+    icon: "/protocols/lido.svg"
+  }
+};

package/src/core/token.ts

@@ -1,4 +1,5 @@
 import { NetworkType } from "./constants";
+import { ConvexPoolContract } from "./contracts";
 
 enum TokenType {
   CONNECTOR,
@@ -9,10 +10,10 @@ enum TokenType {
   YEARN_VAULT_OF_CURVE_LP,
   YEARN_VAULT_OF_META_CURVE_LP,
   CONVEX_LP_TOKEN,
-  CONVEX_STAKED_PHANTOM_TOKEN,
+  CONVEX_STAKED_PHANTOM_TOKEN
 }
 
-export const priority : Record<TokenType, number> = {
+export const priority: Record<TokenType, number> = {
   [TokenType.CONNECTOR]: 1,
   [TokenType.NORMAL_TOKEN]: 2,
   [TokenType.CURVE_LP]: 3,
@@ -24,34 +25,7 @@ export const priority : Record<TokenType, number> = {
   [TokenType.CONVEX_STAKED_PHANTOM_TOKEN]: 5
 };
 
-export type TokenDataI =
-  | {
-      type: TokenType.CONNECTOR;
-    }
-  | {
-      type: TokenType.NORMAL_TOKEN;
-    }
-  | {
-      type: TokenType.CURVE_LP;
-    }
-  | {
-      type: TokenType.YEARN_VAULT;
-      underlying: SupportedTokens,
-    }
-  | {
-      type: TokenType.META_CURVE_LP;
-    }
-  | {
-      type: TokenType.YEARN_VAULT_OF_CURVE_LP;
-    }
-  | {
-      type: TokenType.CONVEX_LP_TOKEN;
-    }
-  | {
-      type: TokenType.YEARN_VAULT_OF_META_CURVE_LP;
-    };
-
-export type SupportedTokens =
+export type NormalToken =
   | "1INCH"
   | "AAVE"
   | "COMP"
@@ -81,229 +55,384 @@ export type SupportedTokens =
   | "sUSD"
   | "GUSD"
   | "LUNA"
-  | "LQTY"
+  | "LQTY";
 
-  // YEARN
-  | "yvDAI"
-  | "yvUSDC"
-  | "yvWETH"
-  | "yvWBTC"
-
-  // CURVE LP TOKENS
+export type CurveLPToken =
   | "3Crv"
   | "steCRV"
   | "FRAX3CRV"
   | "LUSD3CRV"
   | "crvPlain3andSUSD"
-  | "gusd3CRV"
+  | "gusd3CRV";
 
-  // CONVEX LP TOKENS
+export type YearnLPToken =
+  | "yvDAI"
+  | "yvUSDC"
+  | "yvWETH"
+  | "yvWBTC"
+  | "yvCurve_stETH"
+  | "yvCurve_FRAX";
+
+export type ConvexLPToken =
   | "cvx3Crv"
   | "cvxsteCRV"
   | "cvxFRAX3CRV"
   | "cvxcrvPlain3andSUSD"
-  | "cvxgusd3CRV"
+  | "cvxgusd3CRV";
+
+export type ConvexStakedPhantomToken =
+  | "stkcvx3Crv"
+  | "stkcvxsteCRV"
+  | "stkcvxFRAX3CRV"
+  | "stkcvxcrvPlain3andSUSD"
+  | "stkcvxgusd3CRV";
+
+export type SupportedToken =
+  | NormalToken
+  | YearnLPToken
+  | CurveLPToken
+  | ConvexLPToken
+  | ConvexStakedPhantomToken;
 
-  // YEARN- CURVE TOKENS
-  | "yvCurve_stETH"
-  | "yvCurve_FRAX";
+export type TokenDataI =
+  | {
+      symbol: NormalToken;
+      type: TokenType.CONNECTOR;
+    }
+  | {
+      symbol: NormalToken;
+      type: TokenType.NORMAL_TOKEN;
+    }
+  | {
+      symbol: CurveLPToken;
+      type: TokenType.CURVE_LP;
+    }
+  | {
+      symbol: YearnLPToken;
+      type: TokenType.YEARN_VAULT;
+      underlying: NormalToken;
+    }
+  | {
+      symbol: CurveLPToken;
+      type: TokenType.META_CURVE_LP;
+    }
+  | {
+      symbol: YearnLPToken;
+      type: TokenType.YEARN_VAULT_OF_CURVE_LP;
+      underlying: CurveLPToken;
+    }
+  | {
+      symbol: YearnLPToken;
+      type: TokenType.YEARN_VAULT_OF_META_CURVE_LP;
+      underlying: CurveLPToken;
+    }
+  | {
+      symbol: ConvexLPToken;
+      type: TokenType.CONVEX_LP_TOKEN;
+      pool: ConvexPoolContract;
+      underlying: CurveLPToken;
+      stakedToken: ConvexStakedPhantomToken;
+    }
+  | {
+      symbol: ConvexStakedPhantomToken;
+      type: TokenType.CONVEX_STAKED_PHANTOM_TOKEN;
+      pool: ConvexPoolContract;
+      underlying: CurveLPToken;
+      lpToken: ConvexLPToken;
+    };
 
-export const supportedTokens: Record<SupportedTokens, TokenDataI> = {
+export const supportedTokens: Record<SupportedToken, TokenDataI> = {
   "1INCH": {
+    symbol: "1INCH",
     type: TokenType.NORMAL_TOKEN
   },
 
   AAVE: {
+    symbol: "AAVE",
     type: TokenType.NORMAL_TOKEN
   },
 
   COMP: {
+    symbol: "COMP",
     type: TokenType.NORMAL_TOKEN
   },
 
   CRV: {
+    symbol: "CRV",
     type: TokenType.NORMAL_TOKEN
   },
 
   DAI: {
+    symbol: "DAI",
     type: TokenType.CONNECTOR
   },
 
   DPI: {
+    symbol: "DPI",
     type: TokenType.NORMAL_TOKEN
   },
 
   FEI: {
+    symbol: "FEI",
     type: TokenType.NORMAL_TOKEN
   },
 
   LINK: {
+    symbol: "LINK",
     type: TokenType.NORMAL_TOKEN
   },
 
   SNX: {
+    symbol: "SNX",
     type: TokenType.NORMAL_TOKEN
   },
 
   SUSHI: {
+    symbol: "SUSHI",
     type: TokenType.NORMAL_TOKEN
   },
 
   UNI: {
+    symbol: "UNI",
     type: TokenType.NORMAL_TOKEN
   },
 
   USDC: {
+    symbol: "USDC",
     type: TokenType.CONNECTOR
   },
 
   USDT: {
+    symbol: "USDT",
     type: TokenType.NORMAL_TOKEN
   },
 
   WBTC: {
+    symbol: "WBTC",
     type: TokenType.CONNECTOR
   },
 
   WETH: {
+    symbol: "WETH",
     type: TokenType.CONNECTOR
   },
 
   YFI: {
+    symbol: "YFI",
     type: TokenType.NORMAL_TOKEN
   },
 
   /// UPDATE
   STETH: {
+    symbol: "STETH",
     type: TokenType.NORMAL_TOKEN
   },
 
   FTM: {
+    symbol: "FTM",
     type: TokenType.NORMAL_TOKEN
   },
 
   CVX: {
+    symbol: "CVX",
     type: TokenType.NORMAL_TOKEN
   },
 
   FRAX: {
+    symbol: "FRAX",
     type: TokenType.NORMAL_TOKEN
   },
 
   FXS: {
+    symbol: "FXS",
     type: TokenType.NORMAL_TOKEN
   },
 
   LDO: {
+    symbol: "LDO",
     type: TokenType.NORMAL_TOKEN
   },
 
   SPELL: {
+    symbol: "SPELL",
     type: TokenType.NORMAL_TOKEN
   },
 
   LUSD: {
+    symbol: "LUSD",
     type: TokenType.NORMAL_TOKEN
   },
 
   sUSD: {
+    symbol: "sUSD",
     type: TokenType.NORMAL_TOKEN
   },
 
   GUSD: {
+    symbol: "GUSD",
     type: TokenType.NORMAL_TOKEN
   },
 
   LUNA: {
+    symbol: "LUNA",
     type: TokenType.NORMAL_TOKEN
   },
   LQTY: {
+    symbol: "LQTY",
     type: TokenType.NORMAL_TOKEN
   },
 
   // YEARN TOKENS
   yvDAI: {
+    symbol: "yvDAI",
     type: TokenType.YEARN_VAULT,
-    underlying: "DAI",
+    underlying: "DAI"
   },
 
   yvUSDC: {
+    symbol: "yvUSDC",
     type: TokenType.YEARN_VAULT,
     underlying: "USDC"
   },
 
   yvWETH: {
+    symbol: "yvWETH",
     type: TokenType.YEARN_VAULT,
-    underlying: "WETH",
+    underlying: "WETH"
   },
 
   yvWBTC: {
+    symbol: "yvWBTC",
     type: TokenType.YEARN_VAULT,
     underlying: "WBTC"
   },
 
   // CURVE LP TOKENS
-
   "3Crv": {
-    type: TokenType.CURVE_LP
+    symbol: "3Crv",
+    type: TokenType.CURVE_LP,
   },
 
   steCRV: {
+    symbol: "steCRV",
     type: TokenType.CURVE_LP
   },
 
   crvPlain3andSUSD: {
+    symbol: "crvPlain3andSUSD",
     type: TokenType.CURVE_LP
   },
 
   //  META CURVE LP TOKENS
-
   FRAX3CRV: {
+    symbol: "FRAX3CRV",
     type: TokenType.META_CURVE_LP
   },
 
   LUSD3CRV: {
+    symbol: "LUSD3CRV",
     type: TokenType.META_CURVE_LP
   },
 
   gusd3CRV: {
+    symbol: "gusd3CRV",
     type: TokenType.META_CURVE_LP
   },
 
   // CONVEX LP TOKENS
-
   cvx3Crv: {
-    type: TokenType.CONVEX_LP_TOKEN
+    symbol: "cvx3Crv",
+    type: TokenType.CONVEX_LP_TOKEN,
+    pool: "CONVEX_3CRV",
+    underlying: "3Crv",
+    stakedToken: "stkcvx3Crv",
   },
 
   cvxsteCRV: {
-    type: TokenType.CONVEX_LP_TOKEN
+    symbol: "cvxsteCRV",
+    type: TokenType.CONVEX_LP_TOKEN,
+    pool: "CONVEX_STECRV",
+    underlying: "steCRV",
+    stakedToken: "stkcvxsteCRV",
   },
 
   cvxFRAX3CRV: {
-    type: TokenType.CONVEX_LP_TOKEN
+    symbol: "cvxFRAX3CRV",
+    type: TokenType.CONVEX_LP_TOKEN,
+    pool: "CONVEX_FRAX3CRV",
+    underlying: "FRAX3CRV",
+    stakedToken: "stkcvxFRAX3CRV",
   },
 
   cvxcrvPlain3andSUSD: {
-    type: TokenType.CONVEX_LP_TOKEN
+    symbol: "cvxcrvPlain3andSUSD",
+    type: TokenType.CONVEX_LP_TOKEN,
+    pool: "CONVEX_SUSD",
+    underlying: "crvPlain3andSUSD",
+    stakedToken: "stkcvxcrvPlain3andSUSD",
   },
 
   cvxgusd3CRV: {
-    type: TokenType.CONVEX_LP_TOKEN
+    symbol: "cvxgusd3CRV",
+    type: TokenType.CONVEX_LP_TOKEN,
+    pool: "CONVEX_GUSD",
+    underlying: "gusd3CRV",
+    stakedToken: "stkcvxgusd3CRV"
   },
 
   // YEARN- CURVE TOKENS
   yvCurve_stETH: {
-    type: TokenType.YEARN_VAULT_OF_CURVE_LP
+    symbol: "yvCurve_stETH",
+    type: TokenType.YEARN_VAULT_OF_CURVE_LP,
+    underlying: "steCRV"
   },
   yvCurve_FRAX: {
-    type: TokenType.YEARN_VAULT_OF_META_CURVE_LP
+    symbol: "yvCurve_FRAX",
+    type: TokenType.YEARN_VAULT_OF_META_CURVE_LP,
+    underlying: "FRAX3CRV"
+  },
+
+  // STAKED CONVEX
+  stkcvx3Crv: {
+    symbol: "stkcvx3Crv",
+    type: TokenType.CONVEX_STAKED_PHANTOM_TOKEN,
+    pool: "CONVEX_3CRV",
+    underlying: "3Crv",
+    lpToken: "cvx3Crv",
+  },
+  stkcvxsteCRV: {
+    symbol: "stkcvxsteCRV",
+    type: TokenType.CONVEX_STAKED_PHANTOM_TOKEN,
+    pool: "CONVEX_STECRV",
+    underlying: "steCRV",
+    lpToken: "cvxsteCRV",
+  },
+  stkcvxFRAX3CRV: {
+    symbol: "stkcvxFRAX3CRV",
+    type: TokenType.CONVEX_STAKED_PHANTOM_TOKEN,
+    pool: "CONVEX_FRAX3CRV",
+    underlying: "FRAX3CRV",
+    lpToken: "cvxFRAX3CRV",
+  },
+  stkcvxcrvPlain3andSUSD: {
+    symbol: "stkcvxcrvPlain3andSUSD",
+    type: TokenType.CONVEX_STAKED_PHANTOM_TOKEN,
+    pool: "CONVEX_SUSD",
+    underlying: "crvPlain3andSUSD",
+    lpToken: "cvxcrvPlain3andSUSD",
+  },
+  stkcvxgusd3CRV: {
+    symbol: "stkcvxgusd3CRV",
+    type: TokenType.CONVEX_STAKED_PHANTOM_TOKEN,
+    pool: "CONVEX_GUSD",
+    underlying: "gusd3CRV",
+    lpToken: "cvxgusd3CRV"
   }
 };
 
 export const tokenDataByNetwork: Record<
   NetworkType,
-  Record<SupportedTokens, string>
+  Record<SupportedToken, string>
 > = {
   //
   // MAINNET NETWORK
@@ -361,7 +490,11 @@ export const tokenDataByNetwork: Record<
     cvxgusd3CRV: "0x15c2471ef46Fa721990730cfa526BcFb45574576",
 
     // CONVEX PHANTOM TOKEN ADDRESSES
-    // <Provide them here>
+    stkcvx3Crv: "",
+    stkcvxsteCRV: "",
+    stkcvxFRAX3CRV: "",
+    stkcvxcrvPlain3andSUSD: "",
+    stkcvxgusd3CRV: "",
 
     // YEARN- CURVE TOKENS
     yvCurve_stETH: "0xdCD90C7f6324cfa40d7169ef80b12031770B4325",
@@ -425,6 +558,13 @@ export const tokenDataByNetwork: Record<
     cvxcrvPlain3andSUSD: "",
     cvxgusd3CRV: "",
 
+    // CONVEX PHANTOM TOKEN ADDRESSES
+    stkcvx3Crv: "",
+    stkcvxsteCRV: "",
+    stkcvxFRAX3CRV: "",
+    stkcvxcrvPlain3andSUSD: "",
+    stkcvxgusd3CRV: "",
+
     // YEARN- CURVE TOKENS
     yvCurve_stETH: "0xdDc2FA328321573Bc2647C0135D75012c522CDAC",
     yvCurve_FRAX: ""

package/src/core/tokenData.ts

@@ -2,7 +2,7 @@ import { BigNumber } from "ethers";
 import { TokenDataPayload } from "../payload/token";
 import { STATIC_TOKEN } from "../config";
 import { NetworkType } from "./constants";
-import { SupportedTokens, tokenDataByNetwork } from "./token";
+import { SupportedToken, tokenDataByNetwork } from "./token";
 
 export class TokenData {
   public readonly id: string;
@@ -50,7 +50,7 @@ export const WETHToken: Record<NetworkType, string> = {
   Kovan: "0xd0a1e359811322d97991e03f863a0c30c2cf029c",
 };
 
-export const connectors: Record<NetworkType, Array<SupportedTokens>> = {
+export const connectors: Record<NetworkType, Array<SupportedToken>> = {
   Mainnet: [
     "WETH",
     "1INCH",

package/src/devops/loggedDeployer.ts

@@ -0,0 +1,22 @@
+import { Logger } from "tslog";
+
+export abstract class LoggedDeployer {
+  protected readonly _logger: Logger;
+
+  protected constructor() {
+    this._logger = new Logger({
+      minLevel: "error",
+      displayFunctionName: false,
+      displayLoggerName: false,
+      displayFilePath: "hidden",
+    });
+  }
+
+  enableLogs() {
+    this._logger.setSettings({ minLevel: "debug" });
+  }
+
+  disableLogs() {
+    this._logger.setSettings({ minLevel: "error" });
+  }
+}

package/src/devops/verifierDeployer.ts

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2021. Gearbox
+ */
+import { LoggedDeployer } from "./loggedDeployer";
+import * as fs from "fs";
+import { config as dotEnvConfig } from "dotenv";
+import axios from "axios";
+const hre = require("hardhat");
+
+const VERIFIER_FILE = "./.verifier.json"
+
+dotEnvConfig({ path: ".env" });
+
+export interface VerifyRequest {
+  address: string;
+  constructorArguments: Array<any>;
+}
+
+export class Verifier extends LoggedDeployer {
+  protected verifier: Array<VerifyRequest> = [];
+  protected apiKey: string;
+
+  constructor() {
+    super();
+    // this.verifier = verifierJson;
+    // JSON.parse("")
+    this.apiKey = process.env.ETHERSCAN_API_KEY || "";
+    if (this.apiKey === "") throw new Error("No etherscan API provided");
+  }
+
+  addContract(c: VerifyRequest) {
+
+    // Add logic to check if address is already exists
+    this.verifier.push(c);
+    this._saveVerifier();
+  }
+
+  
+
+  async deploy() {
+    this.enableLogs();
+
+    for (let i = 0; i < this.verifier.length; i++) {
+      const params = this.verifier.shift();
+
+      const url = `https://api-kovan.etherscan.io/api?module=contract&action=getabi&address=${params?.address}&apikey=${this.apiKey}`;
+
+      const isVerified = await axios.get(url);
+
+      console.log(isVerified.data)
+
+      if (isVerified.data.status === '1') {
+        this._logger.debug(`${params?.address} is already verified`);
+      } else {
+        this._logger.info(`Verifing: ${params?.address}`);
+        await hre.run("verify:verify", params);
+      }
+
+      this._saveVerifier();
+    }
+  }
+
+  protected _saveVerifier() {
+    fs.writeFileSync(VERIFIER_FILE, JSON.stringify(this.verifier));
+    this._logger.debug("Deploy progress was saved into .verifier.json");
+  }
+}
+
+// const verifier = new Verifier();
+
+// verifier
+//   .deploy()
+//   .then(() => {
+//     process.exit(0);
+//   })
+//   .catch((error) => {
+//     console.error(error);
+//     process.exit(1);
+//   });

package/src/index.ts

@@ -28,6 +28,7 @@ export * from "./utils/math";
 export * from "./core/creditCard";
 export * from "./payload/graphPayload";
 export * from "./types/index";
+export * from "./devops/verifierDeployer";
 
 export type {
   IAppPoolService,
@@ -42,4 +43,4 @@ export * from "./core/history";
 export { MultiCallContract } from "./utils/multicall";
 export { callRepeater } from "./utils/repeater";
 export { getContractName } from "./core/contractsRegister";
-export { AdapterInterface } from "./core/contracts";
+export { AdapterInterface } from "./core/adapters";