@gearbox-protocol/sdk 0.0.54 → 0.0.57

package/lib/pathfinder/yearnVaultOfMetaCurveLPPathAsset.js

@@ -0,0 +1,87 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YearnVaultOfMetaCurveLPPathAsset = void 0;
+var token_1 = require("../core/token");
+var path_1 = require("./path");
+var ethers_1 = require("ethers");
+var YearnVaultOfMetaCurveLPPathAsset = /** @class */ (function (_super) {
+    __extends(YearnVaultOfMetaCurveLPPathAsset, _super);
+    function YearnVaultOfMetaCurveLPPathAsset() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    YearnVaultOfMetaCurveLPPathAsset.prototype.getBestPath = function (currentToken, p) {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentBalance, currentTokenData, outputToken, yearnActionData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentBalance = p.balances[currentToken].sub(1);
+                        currentTokenData = token_1.supportedTokens[currentToken];
+                        outputToken = currentTokenData.lpActions[0].tokenOut;
+                        return [4 /*yield*/, this.getYearnActionData(currentTokenData.lpActions[0], currentBalance, p)];
+                    case 1:
+                        yearnActionData = _a.sent();
+                        p.balances[outputToken].add(yearnActionData.amountOut);
+                        p.balances[currentToken] = ethers_1.BigNumber.from(1);
+                        p.totalGasLimit.add(yearnActionData.gasLimit);
+                        p.calls.push(yearnActionData.callData);
+                        return [4 /*yield*/, p.getBestPath()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return YearnVaultOfMetaCurveLPPathAsset;
+}(path_1.PathAsset));
+exports.YearnVaultOfMetaCurveLPPathAsset = YearnVaultOfMetaCurveLPPathAsset;

package/lib/pathfinder/yearnVaultPathAsset.d.ts

@@ -0,0 +1,5 @@
+import { SupportedToken } from "../core/token";
+import { Path, PathAsset } from "./path";
+export declare class YearnVaultPathAsset extends PathAsset {
+    getBestPath(currentToken: SupportedToken, p: Path): Promise<Path>;
+}

package/lib/pathfinder/yearnVaultPathAsset.js

@@ -0,0 +1,87 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YearnVaultPathAsset = void 0;
+var ethers_1 = require("ethers");
+var token_1 = require("../core/token");
+var path_1 = require("./path");
+var YearnVaultPathAsset = /** @class */ (function (_super) {
+    __extends(YearnVaultPathAsset, _super);
+    function YearnVaultPathAsset() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    YearnVaultPathAsset.prototype.getBestPath = function (currentToken, p) {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentBalance, currentTokenData, outputToken, yearnActionData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentBalance = p.balances[currentToken].sub(1);
+                        currentTokenData = token_1.supportedTokens[currentToken];
+                        outputToken = currentTokenData.lpActions[0].tokenOut;
+                        return [4 /*yield*/, this.getYearnActionData(currentTokenData.lpActions[0], currentBalance, p)];
+                    case 1:
+                        yearnActionData = _a.sent();
+                        p.balances[outputToken].add(yearnActionData.amountOut);
+                        p.balances[currentToken] = ethers_1.BigNumber.from(1);
+                        p.totalGasLimit.add(yearnActionData.gasLimit);
+                        p.calls.push(yearnActionData.callData);
+                        return [4 /*yield*/, p.getBestPath()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return YearnVaultPathAsset;
+}(path_1.PathAsset));
+exports.YearnVaultPathAsset = YearnVaultPathAsset;

package/lib/utils/mappers.d.ts

@@ -0,0 +1,6 @@
+declare type SupportedValue = string | number;
+declare const objectEntries: <K extends SupportedValue, T>(o: Record<K, T>) => [K, T][];
+declare const swapKeyValue: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<T, K>;
+declare const keyToLowercase: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<K, T>;
+export type { SupportedValue };
+export { objectEntries, swapKeyValue, keyToLowercase };

package/lib/utils/mappers.js

@@ -0,0 +1,33 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyToLowercase = exports.swapKeyValue = exports.objectEntries = void 0;
+var objectEntries = function (o) { return Object.entries(o); };
+exports.objectEntries = objectEntries;
+var swapKeyValue = function (o) {
+    return objectEntries(o).reduce(function (sum, _a) {
+        var _b;
+        var key = _a[0], value = _a[1];
+        return __assign(__assign({}, sum), (_b = {}, _b[value] = key, _b));
+    }, {});
+};
+exports.swapKeyValue = swapKeyValue;
+var keyToLowercase = function (o) {
+    return objectEntries(o).reduce(function (sum, _a) {
+        var _b;
+        var key = _a[0], value = _a[1];
+        var keyTransformed = typeof key === "string" ? key.toLowerCase() : key;
+        return __assign(__assign({}, sum), (_b = {}, _b[keyTransformed] = value, _b));
+    }, {});
+};
+exports.keyToLowercase = keyToLowercase;

package/lib/utils/types.d.ts

@@ -0,0 +1,3 @@
+export declare type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};

package/lib/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "0.0.54",
+  "version": "0.0.57",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

package/src/core/adapters.ts

@@ -1,16 +1,15 @@
 export enum AdapterInterface {
-    NO_SWAP, // 0 - 1
-    UNISWAP_V2_ROUTER, // 1 - 2
-    UNISWAP_V3_ROUTER, // 2 - 4
-    CURVE_V1_2ASSETS, // 3 - 8
-    CURVE_V1_3ASSETS, // 4 - 16
-    CURVE_V1_4ASSETS, // 5 - 32
-    CURVE_V1_STECRV_POOL, // 6 - 64
-    YEARN_V2, // 7 - 128
-    CONVEX_V1_BASE_REWARD_POOL, // 8 - 256
-    CONVEX_V1_BOOSTER, // 9 - 512
-    CONVEX_V1_CLAIM_ZAP, // 10 - 1024
-    LIDO_V1 // 11 - 2048
-  }
-  
-  
+  NO_SWAP, // 0 - 1
+  UNISWAP_V2_ROUTER, // 1 - 2
+  UNISWAP_V3_ROUTER, // 2 - 4
+  CURVE_V1_2ASSETS, // 3 - 8
+  CURVE_V1_3ASSETS, // 4 - 16
+  CURVE_V1_4ASSETS, // 5 - 32
+  CURVE_V1_STECRV_POOL, // 6 - 64
+  CURVE_V1_DEPOSIT, // 7 - 128
+  YEARN_V2, // 8 - 256
+  CONVEX_V1_BASE_REWARD_POOL, // 9 - 512
+  CONVEX_V1_BOOSTER, // 10 - 1024
+  CONVEX_V1_CLAIM_ZAP, // 11 - 2048
+  LIDO_V1 // 12 - 4096
+}

package/src/core/contracts.ts

@@ -3,12 +3,16 @@
  * 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 { objectEntries, keyToLowercase, swapKeyValue } from "../utils/mappers";
 import { AdapterInterface } from "./adapters";
 import { NetworkType } from "./constants";
 import { Protocols } from "./protocols";
-import { CurveLPToken, NormalToken, ConvexStakedPhantomToken, tokenDataByNetwork } from "./token";
-
+import {
+  CurveLPToken,
+  NormalToken,
+  ConvexStakedPhantomToken,
+  tokenDataByNetwork
+} from "./token";
 
 export type UniswapV2Contract = "UNISWAP_V2_ROUTER" | "SUSHISWAP_ROUTER";
 
@@ -18,6 +22,7 @@ export type CurvePoolContract =
   | "CURVE_FRAX_POOL"
   | "CURVE_LUSD_POOL"
   | "CURVE_GUSD_POOL"
+  | "CURVE_SUSD_DEPOSIT"
   | "CURVE_SUSD_POOL";
 
 export type YearnVaultContract =
@@ -60,6 +65,7 @@ export const contractsByNetwork: Record<
     CURVE_FRAX_POOL: tokenDataByNetwork.Mainnet.FRAX3CRV,
     CURVE_LUSD_POOL: tokenDataByNetwork.Mainnet.LUSD3CRV,
     CURVE_SUSD_POOL: "0xA5407eAE9Ba41422680e2e00537571bcC53efBfD", // SEPARATE TOKEN
+    CURVE_SUSD_DEPOSIT: "0xFCBa3E75865d2d561BE8D220616520c171F12851",
     CURVE_GUSD_POOL: "0x4f062658EaAF2C1ccf8C8e36D6824CDf41167956", // SEPARATE TOKEN
 
     // YEARN
@@ -93,6 +99,7 @@ export const contractsByNetwork: Record<
     CURVE_FRAX_POOL: "",
     CURVE_LUSD_POOL: tokenDataByNetwork.Kovan.LUSD3CRV,
     CURVE_SUSD_POOL: "0x032f1cE00865F3499C0052ceBA5F2348842416DB", // SEPARATE TOKEN
+    CURVE_SUSD_DEPOSIT: "",
     CURVE_GUSD_POOL: "",
 
     // YEARN
@@ -119,77 +126,110 @@ export const contractsByNetwork: Record<
 
 export const UNISWAP_V3_QUOTER = "0xb27308f9f90d607463bb33ea1bebb41c27ce5ab6";
 
-export interface CurveSteCRVPoolParams {
+export interface BaseContractParams {
+  name: string;
+}
+
+type UniswapV2Params = {
+  protocol: Protocols.Uniswap | Protocols.Sushiswap;
+  type: AdapterInterface.UNISWAP_V2_ROUTER;
+} & BaseContractParams;
+
+type UniswapV3Params = {
+  protocol: Protocols.Uniswap;
+  type: AdapterInterface.UNISWAP_V3_ROUTER;
+  quoter: string;
+} & BaseContractParams;
+
+type CurveParams = {
+  protocol: Protocols.Curve;
+  type:
+    | AdapterInterface.CURVE_V1_2ASSETS
+    | AdapterInterface.CURVE_V1_3ASSETS
+    | AdapterInterface.CURVE_V1_4ASSETS;
+  lpToken: CurveLPToken;
+  tokens: Array<NormalToken | CurveLPToken>;
+} & BaseContractParams;
+
+export type CurveSteCRVPoolParams = {
   protocol: Protocols.Curve;
   type: AdapterInterface.CURVE_V1_STECRV_POOL;
   pool: Record<NetworkType, string>;
   lpToken: "steCRV";
-}
+} & BaseContractParams;
+
+export type CurveDepositParams = {
+  protocol: Protocols.Curve;
+  type: AdapterInterface.CURVE_V1_DEPOSIT;
+  pool: Record<NetworkType, string>;
+  lpToken: CurveLPToken;
+  nCoins: number
+} & BaseContractParams;
+
+type YearnParams = {
+  protocol: Protocols.Yearn;
+  type: AdapterInterface.YEARN_V2;
+} & BaseContractParams;
+
+type ConvexParams = {
+  protocol: Protocols.Convex;
+  type:
+    | AdapterInterface.CONVEX_V1_BOOSTER
+    | AdapterInterface.CONVEX_V1_CLAIM_ZAP;
+} & BaseContractParams;
 
-export interface LidoParams {
+type ConvexPoolParams = {
+  protocol: Protocols.Convex;
+  type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL;
+  stakedToken: ConvexStakedPhantomToken;
+} & BaseContractParams;
+
+export type LidoParams = {
   protocol: Protocols.Lido;
   type: AdapterInterface.LIDO_V1;
   contract: Record<NetworkType, string>;
-}
+  lpToken: "steCRV";
+} & BaseContractParams;
 
 export type ContractParams =
-  | {
-      protocol: Protocols.Uniswap | Protocols.Sushiswap;
-      type: AdapterInterface.UNISWAP_V2_ROUTER;
-    }
-  | {
-      protocol: Protocols.Uniswap;
-      type: AdapterInterface.UNISWAP_V3_ROUTER;
-      quoter: string;
-    }
-  | {
-      protocol: Protocols.Curve;
-      type:
-        | AdapterInterface.CURVE_V1_2ASSETS
-        | AdapterInterface.CURVE_V1_3ASSETS
-        | AdapterInterface.CURVE_V1_4ASSETS;
-      lpToken: CurveLPToken;
-      tokens: Array<NormalToken | CurveLPToken>;
-    }
+  | UniswapV2Params
+  | UniswapV3Params
+  | CurveParams
   | CurveSteCRVPoolParams
-  | {
-      protocol: Protocols.Yearn;
-      type: AdapterInterface.YEARN_V2;
-    }
-  | {
-      protocol: Protocols.Convex;
-      type:
-        | AdapterInterface.CONVEX_V1_BOOSTER
-        | AdapterInterface.CONVEX_V1_CLAIM_ZAP;
-    }
-  | {
-      protocol: Protocols.Convex;
-      type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL;
-      stakedToken: ConvexStakedPhantomToken;
-    }
+  | CurveDepositParams
+  | YearnParams
+  | ConvexParams
+  | ConvexPoolParams
   | LidoParams;
 
 export const contractParams: Record<SupportedContract, ContractParams> = {
   UNISWAP_V2_ROUTER: {
+    name: "Uniswap V2",
     protocol: Protocols.Uniswap,
     type: AdapterInterface.UNISWAP_V2_ROUTER
   },
   UNISWAP_V3_ROUTER: {
+    name: "Uniswap V3",
     protocol: Protocols.Uniswap,
     quoter: UNISWAP_V3_QUOTER,
     type: AdapterInterface.UNISWAP_V3_ROUTER
   },
+
   SUSHISWAP_ROUTER: {
+    name: "Sushiswap",
     protocol: Protocols.Sushiswap,
     type: AdapterInterface.UNISWAP_V2_ROUTER
   },
+
   CURVE_3CRV_POOL: {
+    name: "Curve 3Pool",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_3ASSETS,
     lpToken: "3Crv",
     tokens: ["DAI", "USDC", "USDT"]
   },
   CURVE_STETH_GATEWAY: {
+    name: "Curve stETH",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_STECRV_POOL,
     pool: {
@@ -199,93 +239,131 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     lpToken: "steCRV"
   },
   CURVE_FRAX_POOL: {
+    name: "Curve FRAX",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "FRAX3CRV",
     tokens: ["3Crv", "FRAX"]
   },
   CURVE_LUSD_POOL: {
+    name: "Curve LUSD",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "LUSD3CRV",
     tokens: ["3Crv", "LUSD"]
   },
   CURVE_SUSD_POOL: {
+    name: "Curve SUSD",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_4ASSETS,
     lpToken: "crvPlain3andSUSD",
     tokens: ["DAI", "USDC", "USDT", "sUSD"]
   },
+  CURVE_SUSD_DEPOSIT: {
+      name: "Curve SUSD Deposit",
+      protocol: Protocols.Curve,
+      type: AdapterInterface.CURVE_V1_DEPOSIT,
+      lpToken: "crvPlain3andSUSD",
+      pool: {
+          Mainnet: "0x22eE18aca7F3Ee920D01F25dA85840D12d98E8Ca",
+          Kovan: ""
+      },
+      nCoins: 4
+  },
   CURVE_GUSD_POOL: {
+    name: "Curve GUSD",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "gusd3CRV",
-    tokens: ["3Crv", "FRAX"]
+    tokens: ["3Crv", "GUSD"]
   },
+
   YEARN_DAI_VAULT: {
+    name: "Yearn DAI",
     protocol: Protocols.Yearn,
     type: AdapterInterface.YEARN_V2
   },
-
   YEARN_USDC_VAULT: {
+    name: "Yearn USDC",
     protocol: Protocols.Yearn,
     type: AdapterInterface.YEARN_V2
   },
   YEARN_WETH_VAULT: {
+    name: "Yearn WETH",
     protocol: Protocols.Yearn,
     type: AdapterInterface.YEARN_V2
   },
   YEARN_WBTC_VAULT: {
+    name: "Yearn WBTC",
     protocol: Protocols.Yearn,
     type: AdapterInterface.YEARN_V2
   },
   YEARN_CURVE_FRAX_VAULT: {
+    name: "Yearn Curve FRAX",
     protocol: Protocols.Yearn,
     type: AdapterInterface.YEARN_V2
   },
   YEARN_CURVE_STETH_VAULT: {
+    name: "Yearn Curve STETH",
     protocol: Protocols.Yearn,
     type: AdapterInterface.YEARN_V2
   },
+
   CONVEX_BOOSTER: {
+    name: "Convex BOOSTER",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BOOSTER
   },
   CONVEX_3CRV_POOL: {
+    name: "Convex 3crv",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
     stakedToken: "stkcvx3Crv"
   },
   CONVEX_GUSD_POOL: {
+    name: "Convex GUSD",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
     stakedToken: "stkcvxgusd3CRV"
   },
   CONVEX_SUSD_POOL: {
+    name: "Convex SUSD",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
     stakedToken: "stkcvxcrvPlain3andSUSD"
   },
   CONVEX_STECRV_POOL: {
+    name: "Convex STECRV",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
     stakedToken: "stkcvxsteCRV"
   },
   CONVEX_FRAX3CRV_POOL: {
+    name: "Convex FRAX3CRV",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
     stakedToken: "stkcvxFRAX3CRV"
   },
   CONVEX_CLAIM_ZAP: {
+    name: "Convex ZAP",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_CLAIM_ZAP
   },
+
   LIDO_STETH_GATEWAY: {
+    name: "Lido STETH",
     protocol: Protocols.Lido,
     type: AdapterInterface.LIDO_V1,
     contract: {
       Mainnet: "0xae7ab96520de3a18e5e111b5eaab095312d7fe84",
       Kovan: ""
-    }
+    },
+    lpToken: "steCRV"
   }
 };
+
+export const contractsByAddress = objectEntries(contractsByNetwork).reduce<
+  Record<string, SupportedContract>
+>((sum, [_, contracts]) => {
+  return { ...sum, ...keyToLowercase(swapKeyValue(contracts)) };
+}, {});

package/src/core/contractsRegister.ts

@@ -1,4 +1,5 @@
-
+import { keyToLowercase } from "../utils/mappers";
+import { contractsByAddress, contractParams } from "./contracts";
 
 export const deployedContracts: Record<string, string> = {
   // MAINNET
@@ -11,8 +12,6 @@ export const deployedContracts: Record<string, string> = {
   "0xB2A015c71c17bCAC6af36645DEad8c572bA08A08": "WBTC",
   "0xC38478B0A4bAFE964C3526EEFF534d70E1E09017": "WBTC",
 
-
-
   // [UNISWAP_V2_ROUTER]: "Uniswap V2",
   // [UNISWAP_V3_ROUTER]: "Uniswap V3",
   // [CURVE_3CRV_POOL_ADDRESS]: "Curve 3Pool",
@@ -28,17 +27,26 @@ export const deployedContracts: Record<string, string> = {
   "0xe04b4db67127d1930D36f16B51653120C4285708": "WBTC",
   "0x600073357c29d169aAF3E543A4519749830553F1": "WETH",
   "0xdBAd1361d9A03B81Be8D3a54Ef0dc9e39a1bA5b3": "USDC",
-  "0x50d1fA47b0D88BA0D108148B8481b4A762eFB99e": "DAI",
+  "0x50d1fA47b0D88BA0D108148B8481b4A762eFB99e": "DAI"
   // [YEARN_DAI_VAULT_KOVAN_MOCK]: "Yearn DAI",
   // [YEARN_USDC_VAULT_KOVAN_MOCK]: "Yearn USDC",
   // [SUSHISWAP_KOVAN]: "Sushiswap"
 };
 
+const contractNames = Object.entries(contractsByAddress).reduce<
+  Record<string, string>
+>((sum, [addr, cSymbol]) => {
+  const params = contractParams[cSymbol];
+  if (!params) return sum;
 
+  return { ...sum, [addr]: params.name };
+}, {});
+
+const contractsFullList = {
+  ...keyToLowercase(deployedContracts),
+  ...contractNames
+};
 
 export function getContractName(address: string): string {
-  Object.entries(deployedContracts).forEach(([addr, name]) => {
-    deployedContracts[addr.toLowerCase()] = name;
-  });
-  return deployedContracts[address.toLowerCase()] || address;
+  return contractsFullList[address.toLowerCase()] || address;
 }