@gearbox-protocol/sdk 0.0.102 → 0.0.105

package/lib/utils/loading.js

@@ -1,17 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadingProgress = void 0;
-function loadingProgress() {
-    var params = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        params[_i] = arguments[_i];
-    }
-    var isLoaded = 0;
-    for (var _a = 0, params_1 = params; _a < params_1.length; _a++) {
-        var item = params_1[_a];
-        if (item !== undefined)
-            isLoaded++;
-    }
-    return Math.floor((isLoaded / params.length) * 100);
+exports.loadingProgress = exports.allLoaded = void 0;
+var isLoaded = function (v) { return v !== undefined; };
+function allLoaded(itemsToLoad) {
+    return itemsToLoad.reduce(function (acc, item) { return acc && isLoaded(item); }, true);
+}
+exports.allLoaded = allLoaded;
+function loadingProgress(itemsToLoad) {
+    var loaded = itemsToLoad.reduce(function (acc, item) { return (isLoaded(item) ? acc + 1 : acc); }, 0);
+    return Math.floor((loaded / itemsToLoad.length) * 100);
 }
 exports.loadingProgress = loadingProgress;

package/lib/utils/mappers.js

@@ -18,7 +18,7 @@ var swapKeyValue = function (o) {
     return objectEntries(o).reduce(function (acc, _a) {
         var _b;
         var key = _a[0], value = _a[1];
-        return __assign(__assign({}, acc), (_b = {}, _b[value] = key, _b));
+        return (__assign(__assign({}, acc), (_b = {}, _b[value] = key, _b)));
     }, {});
 };
 exports.swapKeyValue = swapKeyValue;
@@ -35,7 +35,7 @@ var filterEmptyKeys = function (o) {
     return objectEntries(o).reduce(function (acc, _a) {
         var _b;
         var key = _a[0], value = _a[1];
-        return !!key ? __assign(__assign({}, acc), (_b = {}, _b[key] = value, _b)) : acc;
+        return (key ? __assign(__assign({}, acc), (_b = {}, _b[key] = value, _b)) : acc);
     }, {});
 };
 exports.filterEmptyKeys = filterEmptyKeys;

package/lib/utils/network.js

@@ -48,7 +48,7 @@ function detectNetwork(provider) {
                 case 0:
                     _c.trys.push([0, 2, , 7]);
                     usdcMainnet = types_1.ERC20__factory.connect(token_1.tokenDataByNetwork.Mainnet.USDC, provider);
-                    return [4 /*yield*/, usdcMainnet.balanceOf(constants_1.ADDRESS_0x0)];
+                    return [4 /*yield*/, usdcMainnet.balanceOf(constants_1.ADDRESS_0X0)];
                 case 1:
                     _c.sent();
                     return [2 /*return*/, "Mainnet"];
@@ -58,7 +58,7 @@ function detectNetwork(provider) {
                 case 3:
                     _c.trys.push([3, 5, , 6]);
                     usdcMainnet = types_1.ERC20__factory.connect(token_1.tokenDataByNetwork.Kovan.USDC, provider);
-                    return [4 /*yield*/, usdcMainnet.balanceOf(constants_1.ADDRESS_0x0)];
+                    return [4 /*yield*/, usdcMainnet.balanceOf(constants_1.ADDRESS_0X0)];
                 case 4:
                     _c.sent();
                     return [2 /*return*/, "Kovan"];

package/lib/utils/repeater.js

@@ -40,32 +40,20 @@ exports.callRepeater = void 0;
 function callRepeater(call, step) {
     if (step === void 0) { step = 0; }
     return __awaiter(this, void 0, void 0, function () {
-        var _this = this;
         return __generator(this, function (_a) {
-            return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                    var _a, e_1;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                _b.trys.push([0, 2, , 3]);
-                                _a = resolve;
-                                return [4 /*yield*/, call()];
-                            case 1:
-                                _a.apply(void 0, [_b.sent()]);
-                                return [3 /*break*/, 3];
-                            case 2:
-                                e_1 = _b.sent();
-                                console.error("Error ".concat(step, ": ").concat(e_1));
-                                if (step > 5 || e_1.code !== -32000)
-                                    reject(e_1);
-                                else {
-                                    setTimeout(function () { return resolve(callRepeater(call, step + 1)); }, 200);
-                                }
-                                return [3 /*break*/, 3];
-                            case 3: return [2 /*return*/];
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    try {
+                        call().then(function (r) { return resolve(r); });
+                    }
+                    catch (e) {
+                        console.error("Error ".concat(step, ": ").concat(e));
+                        if (step > 5 || e.code !== -32000)
+                            reject(e);
+                        else {
+                            setTimeout(function () { return resolve(callRepeater(call, step + 1)); }, 200);
                         }
-                    });
-                }); })];
+                    }
+                })];
         });
     });
 }

package/lib/utils/validate.js

@@ -6,7 +6,7 @@ function isPositiveFloat(val) {
     if (!floatRegex.test(val))
         return false;
     var valF = parseFloat(val);
-    if (isNaN(valF))
+    if (Number.isNaN(valF))
         return false;
     return true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "0.0.102",
+  "version": "0.0.105",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -9,22 +9,39 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc -w",
-    "pub": "rm -rf ./src/types/hardhat.ts && cp ./src/types/*.d.ts ./lib/types && tsc && yarn publish"
+    "pub": "rm -rf ./src/types/hardhat.ts && cp ./src/types/*.d.ts ./lib/types && tsc && yarn publish",
+    "lint": "eslint . --ext .tsx,.ts --fix",
+    "prepush": "yarn lint --max-warnings=0",
+    "prepare": "husky install"
   },
   "dependencies": {
     "decimal.js-light": "^2.5.1",
     "moment": "^2.29.1"
   },
   "devDependencies": {
-    "@types/jest": "^26.0.4",
-    "@types/node": "^14.0.23",
+    "@types/jest": "^26.0.15",
+    "@types/node": "^17.0.41",
+    "@typescript-eslint/eslint-plugin": "^5.7.0",
+    "@typescript-eslint/parser": "^5.7.0",
     "axios": "^0.27.2",
     "dotenv": "^16.0.1",
-    "ethers": "^5.6.5",
+    "eslint": "^7.11.0",
+    "eslint-config-airbnb": "^19.0.2",
+    "eslint-config-airbnb-typescript": "^16.1.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-import-resolver-typescript": "^2.5.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jsx-a11y": "^6.5.1",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-react": "^7.27.1",
+    "eslint-plugin-react-hooks": "^4.3.0",
+    "ethers": "5.6.9",
+    "husky": "^8.0.0",
+    "husky-init": "^8.0.0",
     "jest": "^26.1.0",
-    "prettier": "^2.3.0",
+    "prettier": "^2.7.1",
     "ts-node": "^10.1.0",
     "tslog": "^3.3.3",
-    "typescript": "^4.2.4"
+    "typescript": "^4.7.3"
   }
 }

package/src/apy/convexAPY.ts

@@ -73,14 +73,14 @@ export async function getConvexApy(
     poolParams.stakedToken
   ] as ConvexPhantomTokenData;
 
-  const underlying = stakedTokenParams.underlying;
+  const { underlying } = stakedTokenParams;
   const basePoolAddress = contractsList[pool];
   const swapPoolAddress = contractsList[curveSwapByPool[pool]];
   const cvxAddress = tokenList.CVX;
 
-  const extraPoolAddresses = poolParams.extraRewards.map(d => {
-    return d.poolAddress[networkType];
-  });
+  const extraPoolAddresses = poolParams.extraRewards.map(
+    d => d.poolAddress[networkType]
+  );
 
   const [basePoolRate, basePoolSupply, vPrice, cvxSupply, ...extra] =
     await getPoolData(
@@ -91,8 +91,8 @@ export async function getConvexApy(
       provider
     );
 
-  const cvxPrice = getTokenPrice(tokenList["CVX"]);
-  const crvPrice = getTokenPrice(tokenList["CRV"]);
+  const cvxPrice = getTokenPrice(tokenList.CVX);
+  const crvPrice = getTokenPrice(tokenList.CRV);
 
   const crvPerSecond = basePoolRate;
   const virtualSupply = basePoolSupply.mul(vPrice).div(WAD);

package/src/apy/lidoAPY.ts

@@ -17,10 +17,9 @@ type ILidoOracleInterface = ILidoOracle["interface"];
 
 type IstETHInterface = IstETH["interface"];
 
-const lidoOracleAddress = (contractParams.LIDO_STETH_GATEWAY as LidoParams)
-  .oracle;
+const lidoOracles = (contractParams.LIDO_STETH_GATEWAY as LidoParams).oracle;
 
-const lidoStEthAddress: Record<NetworkType, string> = {
+const lidoStEth: Record<NetworkType, string> = {
   Mainnet: tokenDataByNetwork.Mainnet.STETH,
   Kovan: tokenDataByNetwork.Kovan.STETH
 };
@@ -29,17 +28,19 @@ export async function getLidoApy(
   provider: providers.Provider,
   networkType: NetworkType
 ) {
-  if (!lidoOracleAddress[networkType]) {
-    throw `No Lido APR oracle found on current network: ${networkType}`;
+  if (!lidoOracles[networkType]) {
+    throw new Error(
+      `No Lido APR oracle found on current network: ${networkType}`
+    );
   }
-  if (!lidoStEthAddress[networkType]) {
-    throw `No Lido stETH found on current network: ${networkType}`;
+  if (!lidoStEth[networkType]) {
+    throw new Error(`No Lido stETH found on current network: ${networkType}`);
   }
 
   const [{ postTotalPooledEther, preTotalPooledEther, timeElapsed }, fee] =
     await geLidoData(
-      lidoOracleAddress[networkType],
-      lidoStEthAddress[networkType],
+      lidoOracles[networkType],
+      lidoStEth[networkType],
       provider,
       networkType
     );
@@ -53,6 +54,8 @@ export async function getLidoApy(
   return [lidoAPRRay, fee] as const;
 }
 
+export const LIDO_FEE_DECIMALS = 10000;
+
 async function geLidoData(
   lidoOracleAddress: string,
   stETHAddress: string,
@@ -84,5 +87,3 @@ async function geLidoData(
 
   return [stats, fee] as const;
 }
-
-export const LIDO_FEE_DECIMALS = 10000;

package/src/contracts/contracts.ts

@@ -3,6 +3,7 @@
  * 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 type { YearnLPToken } from "../tokens/yearn";
 import {
   keyToLowercase,
   objectEntries,
@@ -14,7 +15,7 @@ import { NetworkType } from "../core/constants";
 import { Protocols } from "./protocols";
 import { tokenDataByNetwork } from "../tokens/token";
 import { ConvexStakedPhantomToken } from "../tokens/convex";
-import { CurveLPToken } from "../tokens/curveLP";
+import type { CurveLPToken } from "../tokens/curveLP";
 import { NormalToken } from "../tokens/normal";
 
 export type UniswapV2Contract = "UNISWAP_V2_ROUTER" | "SUSHISWAP_ROUTER";
@@ -169,12 +170,14 @@ export type CurveSteCRVPoolParams = {
   protocol: Protocols.Curve;
   type: AdapterInterface.CURVE_V1_STECRV_POOL;
   pool: Record<NetworkType, string>;
+  tokens: ["WETH", "STETH"];
   lpToken: "steCRV";
 } & BaseContractParams;
 
-type YearnParams = {
+export type YearnParams = {
   protocol: Protocols.Yearn;
   type: AdapterInterface.YEARN_V2;
+  shareToken: YearnLPToken;
 } & BaseContractParams;
 
 type ConvexParams = {
@@ -247,6 +250,7 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
       Mainnet: "0xDC24316b9AE028F1497c275EB9192a3Ea0f67022",
       Kovan: "0xF5C73b58B70709e89aA1D322d48b0D0C71123cB4"
     },
+    tokens: ["WETH", "STETH"],
     lpToken: "steCRV"
   },
   CURVE_FRAX_POOL: {
@@ -254,14 +258,14 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "FRAX3CRV",
-    tokens: ["3Crv", "FRAX"]
+    tokens: ["FRAX", "3Crv"]
   },
   CURVE_LUSD_POOL: {
     name: "Curve LUSD",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "LUSD3CRV",
-    tokens: ["3Crv", "LUSD"]
+    tokens: ["LUSD", "3Crv"]
   },
   CURVE_SUSD_POOL: {
     name: "Curve SUSD",
@@ -277,8 +281,7 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_WRAPPER,
     lpToken: "crvPlain3andSUSD",
-    tokens: ["DAI", "USDC", "USDT", "sUSD"],
-    wrapper: "CURVE_SUSD_DEPOSIT"
+    tokens: ["DAI", "USDC", "USDT", "sUSD"]
   },
 
   CURVE_GUSD_POOL: {
@@ -286,38 +289,44 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "gusd3CRV",
-    tokens: ["3Crv", "FRAX"]
+    tokens: ["GUSD", "3Crv"]
   },
 
   YEARN_DAI_VAULT: {
     name: "Yearn DAI",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvDAI"
   },
   YEARN_USDC_VAULT: {
     name: "Yearn USDC",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvUSDC"
   },
   YEARN_WETH_VAULT: {
     name: "Yearn WETH",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvWETH"
   },
   YEARN_WBTC_VAULT: {
     name: "Yearn WBTC",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvWBTC"
   },
   YEARN_CURVE_FRAX_VAULT: {
     name: "Yearn Curve FRAX",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvCurve_FRAX"
   },
   YEARN_CURVE_STETH_VAULT: {
     name: "Yearn Curve STETH",
     protocol: Protocols.Yearn,
-    type: AdapterInterface.YEARN_V2
+    type: AdapterInterface.YEARN_V2,
+    shareToken: "yvCurve_stETH"
   },
 
   CONVEX_BOOSTER: {
@@ -420,9 +429,10 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
 
 export const contractsByAddress = objectEntries(contractsByNetwork).reduce<
   Record<string, SupportedContract>
->((acc, [_, contracts]) => {
-  return {
+>(
+  (acc, [, contracts]) => ({
     ...acc,
     ...filterEmptyKeys(keyToLowercase(swapKeyValue(contracts)))
-  };
-}, {});
+  }),
+  {}
+);

package/src/core/constants.ts

@@ -48,4 +48,4 @@ export const timeRanges: Record<string, number> = {
 
 export const LEVERAGE_DECIMALS = 100;
 export const SLIPPAGE_DECIMALS = 100;
-export const ADDRESS_0x0 = "0x0000000000000000000000000000000000000000";
+export const ADDRESS_0X0 = "0x0000000000000000000000000000000000000000";

package/src/core/creditAccount.ts

@@ -18,19 +18,33 @@ export class CreditAccountData {
   public readonly id: string;
 
   public readonly addr: string;
+
   public readonly borrower: string;
+
   public readonly inUse: boolean;
+
   public readonly creditManager: string;
+
   public readonly underlyingToken: string;
+
   public borrowedAmountPlusInterest: BigNumber;
+
   public totalValue: BigNumber;
+
   public healthFactor: number;
+
   public borrowRate: number;
+
   public readonly allowedTokens: Array<string> = [];
+
   public readonly allTokens: Array<string> = [];
+
   public balances: Record<string, BigNumber> = {};
+
   public allBalances: Record<string, BigNumber> = {};
+
   public isDeleting: boolean;
+
   public readonly version: number = 1;
 
   constructor(payload: CreditAccountDataPayload) {
@@ -94,11 +108,15 @@ export function sortBalances(
     const totalPrice1 = calcTotalPrice(price1, amount1, token1?.decimals);
     const totalPrice2 = calcTotalPrice(price2, amount2, token2?.decimals);
 
-    return totalPrice1.eq(totalPrice2)
-      ? tokensAbcComparator(token1, token2)
-      : totalPrice1.gt(totalPrice2)
-      ? -1
-      : 1;
+    if (totalPrice1.eq(totalPrice2)) {
+      return tokensAbcComparator(token1, token2);
+    }
+
+    if (totalPrice1.gt(totalPrice2)) {
+      return -1;
+    }
+
+    return 1;
   });
 }
 
@@ -111,10 +129,15 @@ export function tokensAbcComparator(t1?: TokenData, t2?: TokenData) {
 
 export class CreditAccountDataExtended extends CreditAccountData {
   public readonly repayAmount: BigNumber;
+
   public readonly liquidationAmount: BigNumber;
+
   public readonly borrowedAmount: BigNumber;
+
   public readonly canBeClosed: boolean;
+
   public readonly cumulativeIndexAtOpen: BigNumber;
+
   public readonly since: number;
 
   constructor(payload: CreditAccountDataExtendedPayload) {

package/src/core/creditManager.ts

@@ -22,26 +22,45 @@ import { OpenAccountError } from "./errors";
 
 export class CreditManagerData {
   public readonly id: string;
+
   public readonly address: string;
+
   public readonly underlyingToken: string;
+
   public readonly isWETH: boolean;
+
   public readonly canBorrow: boolean;
+
   public readonly borrowRate: number;
+
   public readonly minAmount: BigNumber;
+
   public readonly maxAmount: BigNumber;
+
   public readonly maxLeverageFactor: number; // for V1 only
+
   public readonly availableLiquidity: BigNumber;
+
   public readonly allowedTokens: Array<string>;
+
   public readonly adapters: Record<string, string>;
 
   public readonly liquidationThresholds: Record<string, BigNumber>;
+
   public readonly version: number;
+
   public readonly creditFacade: string; // V2 only: address of creditFacade
+
   public readonly isDegenMode: boolean; // V2 only: true if contract is in Degen mode
+
   public readonly degenNFT: string; // V2 only: degenNFT, address(0) if not in degen mode
+
   public readonly isIncreaseDebtForbidden: boolean; // V2 only: true if increasing debt is forbidden
+
   public readonly forbiddenTokenMask: BigNumber; // V2 only: mask which forbids some particular tokens
 
+  public readonly isPaused: boolean = false;
+
   constructor(payload: CreditManagerDataPayload) {
     this.id = payload.addr;
     this.address = payload.addr;
@@ -92,10 +111,6 @@ export class CreditManagerData {
     this.forbiddenTokenMask = BigNumber.from(payload.forbiddenTokenMask || 0);
   }
 
-  get isPaused(): boolean {
-    return false;
-  }
-
   getContractETH(signer: Signer | ethers.providers.Provider): ICreditManager {
     return ICreditManager__factory.connect(this.address, signer);
   }
@@ -229,15 +244,25 @@ export function calcHealthFactorAfterAddingCollateral(
 
 export class CreditManagerStat extends CreditManagerData {
   public readonly uniqueUsers: number;
+
   public readonly openedAccountsCount: number;
+
   public readonly totalOpenedAccounts: number;
+
   public readonly totalClosedAccounts: number;
+
   public readonly totalRepaidAccounts: number;
+
   public readonly totalLiquidatedAccounts: number;
+
   public readonly totalBorrowed: BigNumber;
+
   public readonly cumulativeBorrowed: BigNumber;
+
   public readonly totalRepaid: BigNumber;
+
   public readonly totalProfit: BigNumber;
+
   public readonly totalLosses: BigNumber;
 
   constructor(payload: CreditManagerStatPayload) {

package/src/core/creditOperation.ts

@@ -1,9 +1,9 @@
 export interface CreditOperation {
-    id: number,
-    txHash: string,
-    blockNum: number,
-    protocol: string,
-    operation: string,
-    timestamp: number,
-    date: string
+  id: number;
+  txHash: string;
+  blockNum: number;
+  protocol: string;
+  operation: string;
+  timestamp: number;
+  date: string;
 }

package/src/core/creditSession.ts

@@ -1,7 +1,7 @@
 import { BigNumber } from "ethers";
+import moment from "moment";
 import { CreditOperation } from "./creditOperation";
 import { CreditSessionPayload } from "../payload/creditSession";
-import moment from "moment";
 import { PERCENTAGE_FACTOR } from "./constants";
 
 export type CreditSessionStatus = "active" | "closed" | "repaid" | "liquidated";
@@ -10,29 +10,46 @@ const statusEnum: Array<CreditSessionStatus> = [
   "active",
   "closed",
   "repaid",
-  "liquidated",
+  "liquidated"
 ];
 
 export class CreditSession {
   public readonly id: string;
 
   public readonly status: CreditSessionStatus;
+
   public readonly name: string;
+
   public readonly background: string;
+
   public readonly borrower: string;
+
   public readonly creditManager: string;
+
   public readonly account: string;
+
   public readonly since: number;
+
   public readonly sinceDate: string;
+
   public readonly closedAt: number;
+
   public readonly closedAtDate: string;
+
   public readonly initialAmount: BigNumber;
+
   public readonly borrowedAmount: BigNumber;
+
   public readonly totalValue: BigNumber;
+
   public readonly healthFactor: number;
+
   public readonly profit: BigNumber;
+
   public readonly profitPercentage: number;
+
   public readonly score: number;
+
   public readonly operations: Array<CreditOperation>;
 
   constructor(payload: CreditSessionPayload) {
@@ -53,9 +70,12 @@ export class CreditSession {
     this.healthFactor =
       BigNumber.from(payload.healthFactor || 0).toNumber() / PERCENTAGE_FACTOR;
     this.score = payload.score;
-    this.operations = (payload.operations || []).map((op) => {
-      op.date = moment(op.timestamp * 1000).format("Do MMM YYYY");
-      return op;
+    this.operations = (payload.operations || []).map(op => {
+      const formattedOp = {
+        ...op,
+        date: moment(op.timestamp * 1000).format("Do MMM YYYY")
+      };
+      return formattedOp;
     });
     this.sinceDate = moment(payload.sinceTimestamp * 1000).format(
       "Do MMM YYYY"

package/src/core/errors.ts

@@ -54,6 +54,7 @@ export type OpenAccountErrorTypes =
 
 export class OpenAccountError extends Error {
   message: OpenAccountErrorTypes;
+
   payload: { amount: BigNumber };
 
   constructor(errorType: OpenAccountErrorTypes, amount: BigNumber) {