@gearbox-protocol/sdk 0.0.102 → 0.0.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "0.0.102",
+  "version": "0.0.103",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -9,22 +9,40 @@
   "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"
+    "moment": "^2.29.1",
+    "prettier": "^2.7.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

@@ -13,9 +13,9 @@ import { AdapterInterface } from "./adapters";
 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 { NormalToken } from "../tokens/normal";
+import type { ConvexStakedPhantomToken } from "../tokens/convex";
+import type { CurveLPToken } from "../tokens/curveLP";
+import type { NormalToken } from "../tokens/normal";
 
 export type UniswapV2Contract = "UNISWAP_V2_ROUTER" | "SUSHISWAP_ROUTER";
 
@@ -420,9 +420,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) {

package/src/core/eventOrTx.ts

@@ -1,5 +1,5 @@
 import { TokenData } from "../tokens/tokenData";
-import { TxSerialized } from "./transactions";
+import type { TxSerialized } from "./transactions";
 
 export interface Display {
   toString(tokenData: Record<string, TokenData>): string;
@@ -16,8 +16,11 @@ export interface EventOrTxProps {
 
 export abstract class EventOrTx implements Display {
   public block: number;
+
   public readonly txHash: string;
+
   public readonly timestamp: number;
+
   protected _txStatus: TxStatus;
 
   constructor({ block, txHash, txStatus, timestamp = 0 }: EventOrTxProps) {
@@ -70,10 +73,10 @@ export abstract class EVMTx extends EventOrTx {
     timestamp = 0
   }: EVMTxProps) {
     super({
-      block: block,
-      txStatus: txStatus,
-      txHash: txHash,
-      timestamp: timestamp
+      block,
+      txStatus,
+      txHash,
+      timestamp
     });
     if (this.txStatus !== "pending" && this.block === 0) {
       throw new Error("Block not specified for non-pending tx");