@gearbox-protocol/sdk 0.0.39 → 0.0.42

package/lib/core/protocols.js

@@ -0,0 +1,39 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protocolData = exports.Protocols = void 0;
+var Protocols;
+(function (Protocols) {
+    Protocols[Protocols["Uniswap"] = 0] = "Uniswap";
+    Protocols[Protocols["Sushiswap"] = 1] = "Sushiswap";
+    Protocols[Protocols["Curve"] = 2] = "Curve";
+    Protocols[Protocols["Yearn"] = 3] = "Yearn";
+    Protocols[Protocols["Convex"] = 4] = "Convex";
+    Protocols[Protocols["Lido"] = 5] = "Lido";
+})(Protocols = exports.Protocols || (exports.Protocols = {}));
+exports.protocolData = (_a = {},
+    _a[Protocols.Uniswap] = {
+        name: "Uniswap",
+        icon: "/protocols/uniswap.png"
+    },
+    _a[Protocols.Sushiswap] = {
+        name: "Sushiswap",
+        icon: "/protocols/sushi.svg"
+    },
+    _a[Protocols.Curve] = {
+        name: "Curve",
+        icon: "/protocols/curve.svg"
+    },
+    _a[Protocols.Yearn] = {
+        name: "Yearn",
+        icon: "/protocols/yearn.svg"
+    },
+    _a[Protocols.Convex] = {
+        name: "Convex",
+        icon: "/protocols/convex.svg"
+    },
+    _a[Protocols.Lido] = {
+        name: "Lido",
+        icon: "/protocols/lido.svg"
+    },
+    _a);

package/lib/core/token.d.ts

@@ -1,4 +1,5 @@
 import { NetworkType } from "./constants";
+import { ConvexPoolContract } from "./contracts";
 declare enum TokenType {
     CONNECTOR = 0,
     NORMAL_TOKEN = 1,
@@ -11,25 +12,49 @@ declare enum TokenType {
     CONVEX_STAKED_PHANTOM_TOKEN = 8
 }
 export declare const priority: Record<TokenType, number>;
+export declare type NormalToken = "1INCH" | "AAVE" | "COMP" | "CRV" | "DAI" | "DPI" | "FEI" | "LINK" | "SNX" | "SUSHI" | "UNI" | "USDC" | "USDT" | "WBTC" | "WETH" | "YFI" | "STETH" | "FTM" | "CVX" | "FRAX" | "FXS" | "LDO" | "SPELL" | "LUSD" | "sUSD" | "GUSD" | "LUNA" | "LQTY";
+export declare type CurveLPToken = "3Crv" | "steCRV" | "FRAX3CRV" | "LUSD3CRV" | "crvPlain3andSUSD" | "gusd3CRV";
+export declare type YearnLPToken = "yvDAI" | "yvUSDC" | "yvWETH" | "yvWBTC" | "yvCurve_stETH" | "yvCurve_FRAX";
+export declare type ConvexLPToken = "cvx3Crv" | "cvxsteCRV" | "cvxFRAX3CRV" | "cvxcrvPlain3andSUSD" | "cvxgusd3CRV";
+export declare type ConvexStakedPhantomToken = "stkcvx3Crv" | "stkcvxsteCRV" | "stkcvxFRAX3CRV" | "stkcvxcrvPlain3andSUSD" | "stkcvxgusd3CRV";
+export declare type SupportedToken = NormalToken | YearnLPToken | CurveLPToken | ConvexLPToken | ConvexStakedPhantomToken;
 export declare 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: SupportedTokens;
+    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;
 } | {
-    type: TokenType.YEARN_VAULT_OF_META_CURVE_LP;
+    symbol: ConvexStakedPhantomToken;
+    type: TokenType.CONVEX_STAKED_PHANTOM_TOKEN;
+    pool: ConvexPoolContract;
+    underlying: CurveLPToken;
+    lpToken: ConvexLPToken;
 };
-export declare type SupportedTokens = "1INCH" | "AAVE" | "COMP" | "CRV" | "DAI" | "DPI" | "FEI" | "LINK" | "SNX" | "SUSHI" | "UNI" | "USDC" | "USDT" | "WBTC" | "WETH" | "YFI" | "STETH" | "FTM" | "CVX" | "FRAX" | "FXS" | "LDO" | "SPELL" | "LUSD" | "sUSD" | "GUSD" | "LUNA" | "LQTY" | "yvDAI" | "yvUSDC" | "yvWETH" | "yvWBTC" | "3Crv" | "steCRV" | "FRAX3CRV" | "LUSD3CRV" | "crvPlain3andSUSD" | "gusd3CRV" | "cvx3Crv" | "cvxsteCRV" | "cvxFRAX3CRV" | "cvxcrvPlain3andSUSD" | "cvxgusd3CRV" | "yvCurve_stETH" | "yvCurve_FRAX";
-export declare const supportedTokens: Record<SupportedTokens, TokenDataI>;
-export declare const tokenDataByNetwork: Record<NetworkType, Record<SupportedTokens, string>>;
+export declare const supportedTokens: Record<SupportedToken, TokenDataI>;
+export declare const tokenDataByNetwork: Record<NetworkType, Record<SupportedToken, string>>;
 export {};

package/lib/core/token.js

@@ -27,149 +27,247 @@ exports.priority = (_a = {},
     _a);
 exports.supportedTokens = {
     "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"
     }
 };
 exports.tokenDataByNetwork = {
@@ -224,7 +322,11 @@ exports.tokenDataByNetwork = {
         cvxcrvPlain3andSUSD: "0x11D200ef1409cecA8D6d23e6496550f707772F11",
         cvxgusd3CRV: "0x15c2471ef46Fa721990730cfa526BcFb45574576",
         // CONVEX PHANTOM TOKEN ADDRESSES
-        // <Provide them here>
+        stkcvx3Crv: "",
+        stkcvxsteCRV: "",
+        stkcvxFRAX3CRV: "",
+        stkcvxcrvPlain3andSUSD: "",
+        stkcvxgusd3CRV: "",
         // YEARN- CURVE TOKENS
         yvCurve_stETH: "0xdCD90C7f6324cfa40d7169ef80b12031770B4325",
         yvCurve_FRAX: "0xB4AdA607B9d6b2c9Ee07A275e9616B84AC560139"
@@ -281,6 +383,12 @@ exports.tokenDataByNetwork = {
         cvxFRAX3CRV: "",
         cvxcrvPlain3andSUSD: "",
         cvxgusd3CRV: "",
+        // CONVEX PHANTOM TOKEN ADDRESSES
+        stkcvx3Crv: "",
+        stkcvxsteCRV: "",
+        stkcvxFRAX3CRV: "",
+        stkcvxcrvPlain3andSUSD: "",
+        stkcvxgusd3CRV: "",
         // YEARN- CURVE TOKENS
         yvCurve_stETH: "0xdDc2FA328321573Bc2647C0135D75012c522CDAC",
         yvCurve_FRAX: ""

package/lib/core/tokenData.d.ts

@@ -1,7 +1,7 @@
 import { BigNumber } from "ethers";
 import { TokenDataPayload } from "../payload/token";
 import { NetworkType } from "./constants";
-import { SupportedTokens } from "./token";
+import { SupportedToken } from "./token";
 export declare class TokenData {
     readonly id: string;
     readonly symbol: string;
@@ -24,5 +24,5 @@ export interface TokenSavedData {
     type: TokenType;
 }
 export declare const WETHToken: Record<NetworkType, string>;
-export declare const connectors: Record<NetworkType, Array<SupportedTokens>>;
+export declare const connectors: Record<NetworkType, Array<SupportedToken>>;
 export declare function getConnectors(networkType: NetworkType): string[];

package/lib/devops/loggedDeployer.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from "tslog";
+export declare abstract class LoggedDeployer {
+    protected readonly _logger: Logger;
+    protected constructor();
+    enableLogs(): void;
+    disableLogs(): void;
+}

package/lib/devops/loggedDeployer.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggedDeployer = void 0;
+var tslog_1 = require("tslog");
+var LoggedDeployer = /** @class */ (function () {
+    function LoggedDeployer() {
+        this._logger = new tslog_1.Logger({
+            minLevel: "error",
+            displayFunctionName: false,
+            displayLoggerName: false,
+            displayFilePath: "hidden",
+        });
+    }
+    LoggedDeployer.prototype.enableLogs = function () {
+        this._logger.setSettings({ minLevel: "debug" });
+    };
+    LoggedDeployer.prototype.disableLogs = function () {
+        this._logger.setSettings({ minLevel: "error" });
+    };
+    return LoggedDeployer;
+}());
+exports.LoggedDeployer = LoggedDeployer;

package/lib/devops/verifierDeployer.d.ts

@@ -0,0 +1,13 @@
+import { LoggedDeployer } from "./loggedDeployer";
+export interface VerifyRequest {
+    address: string;
+    constructorArguments: Array<any>;
+}
+export declare class Verifier extends LoggedDeployer {
+    protected verifier: Array<VerifyRequest>;
+    protected apiKey: string;
+    constructor();
+    addContract(c: VerifyRequest): void;
+    deploy(): Promise<void>;
+    protected _saveVerifier(): void;
+}

package/lib/devops/verifierDeployer.js

@@ -0,0 +1,161 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Verifier = void 0;
+/*
+ * Copyright (c) 2021. Gearbox
+ */
+var loggedDeployer_1 = require("./loggedDeployer");
+var fs = __importStar(require("fs"));
+var dotenv_1 = require("dotenv");
+var axios_1 = __importDefault(require("axios"));
+var hre = require("hardhat");
+var VERIFIER_FILE = "./.verifier.json";
+(0, dotenv_1.config)({ path: ".env" });
+var Verifier = /** @class */ (function (_super) {
+    __extends(Verifier, _super);
+    function Verifier() {
+        var _this = _super.call(this) || this;
+        _this.verifier = [];
+        // this.verifier = verifierJson;
+        // JSON.parse("")
+        _this.apiKey = process.env.ETHERSCAN_API_KEY || "";
+        if (_this.apiKey === "")
+            throw new Error("No etherscan API provided");
+        return _this;
+    }
+    Verifier.prototype.addContract = function (c) {
+        // Add logic to check if address is already exists
+        this.verifier.push(c);
+        this._saveVerifier();
+    };
+    Verifier.prototype.deploy = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var i, params, url, isVerified;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.enableLogs();
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < this.verifier.length)) return [3 /*break*/, 7];
+                        params = this.verifier.shift();
+                        url = "https://api-kovan.etherscan.io/api?module=contract&action=getabi&address=".concat(params === null || params === void 0 ? void 0 : params.address, "&apikey=").concat(this.apiKey);
+                        return [4 /*yield*/, axios_1.default.get(url)];
+                    case 2:
+                        isVerified = _a.sent();
+                        console.log(isVerified.data);
+                        if (!(isVerified.data.status === '1')) return [3 /*break*/, 3];
+                        this._logger.debug("".concat(params === null || params === void 0 ? void 0 : params.address, " is already verified"));
+                        return [3 /*break*/, 5];
+                    case 3:
+                        this._logger.info("Verifing: ".concat(params === null || params === void 0 ? void 0 : params.address));
+                        return [4 /*yield*/, hre.run("verify:verify", params)];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        this._saveVerifier();
+                        _a.label = 6;
+                    case 6:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Verifier.prototype._saveVerifier = function () {
+        fs.writeFileSync(VERIFIER_FILE, JSON.stringify(this.verifier));
+        this._logger.debug("Deploy progress was saved into .verifier.json");
+    };
+    return Verifier;
+}(loggedDeployer_1.LoggedDeployer));
+exports.Verifier = Verifier;
+// const verifier = new Verifier();
+// verifier
+//   .deploy()
+//   .then(() => {
+//     process.exit(0);
+//   })
+//   .catch((error) => {
+//     console.error(error);
+//     process.exit(1);
+//   });

package/lib/index.d.ts

@@ -28,9 +28,10 @@ export * from "./utils/math";
 export * from "./core/creditCard";
 export * from "./payload/graphPayload";
 export * from "./types/index";
+export * from "./devops/verifierDeployer";
 export type { IAppPoolService, IAppCreditManager, IAppERC20, IAppAddressProvider, IDataCompressor, IWETHGateway } from "./types";
 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";

package/lib/index.js

@@ -45,6 +45,7 @@ __exportStar(require("./utils/math"), exports);
 __exportStar(require("./core/creditCard"), exports);
 __exportStar(require("./payload/graphPayload"), exports);
 __exportStar(require("./types/index"), exports);
+__exportStar(require("./devops/verifierDeployer"), exports);
 __exportStar(require("./core/history"), exports);
 var multicall_1 = require("./utils/multicall");
 Object.defineProperty(exports, "MultiCallContract", { enumerable: true, get: function () { return multicall_1.MultiCallContract; } });
@@ -52,5 +53,5 @@ var repeater_1 = require("./utils/repeater");
 Object.defineProperty(exports, "callRepeater", { enumerable: true, get: function () { return repeater_1.callRepeater; } });
 var contractsRegister_1 = require("./core/contractsRegister");
 Object.defineProperty(exports, "getContractName", { enumerable: true, get: function () { return contractsRegister_1.getContractName; } });
-var contracts_1 = require("./core/contracts");
-Object.defineProperty(exports, "AdapterInterface", { enumerable: true, get: function () { return contracts_1.AdapterInterface; } });
+var adapters_1 = require("./core/adapters");
+Object.defineProperty(exports, "AdapterInterface", { enumerable: true, get: function () { return adapters_1.AdapterInterface; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "0.0.39",
+  "version": "0.0.42",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -16,12 +16,16 @@
     "moment": "^2.29.1"
   },
   "devDependencies": {
+    "@types/axios": "^0.14.0",
     "@types/jest": "^26.0.4",
     "@types/node": "^14.0.23",
-    "ethers": "^5.4.5",
+    "axios": "^0.27.2",
+    "dotenv": "^16.0.1",
+    "ethers": "^5.6.5",
     "jest": "^26.1.0",
     "prettier": "^2.3.0",
     "ts-node": "^10.1.0",
+    "tslog": "^3.3.3",
     "typescript": "^4.2.4"
   }
 }