@gearbox-protocol/sdk 0.0.101 → 0.0.104

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 "src/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/contracts/contractsRegister.ts

@@ -27,10 +27,25 @@ 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"
+
+  "0x94cd5F09727ae04d7D6fd36A9c9DD96D0d54646B": "DAI",
+  "0x53B4a7389EA369a9299DfF524f916EC3cB77ffF4": "USDC",
+  "0xE6631f7b18744651A385a02ea2C89634d20D7819": "WETH",
+  "0x4d2cBA0E43Ad3B3E1C3B1922fe6E8e910b8C3ae0": "WBTC",
+
+  "0x6Ae9Ed829AF469Df9526FA7443E876bfaBC79eff": "DAI V2",
+  "0x8E0a874E3475de1C16490E386b7E2904CdC03086": "USDC V2",
+  "0x816a74B75D60839247C848518545fb17cedDC460": "WETH V2",
+
+  // pools
+  "0xA7b1C8f322596C40A04dBd3DffaE37a0849B8b59": "DAI",
+  "0xb8ecDB926F07FCbd870eafE72d116413A0BEb236": "USDC",
+  "0xAda6b2747295b2ba6ba52ce2d0D5e681D25D63D8": "WETH",
+  "0x85c54CCCf27466eEa1C74a73F75CbE385C271EE4": "WBTC"
 };
 
 const contractNames = Object.entries(contractsByAddress).reduce<

package/src/core/constants.ts

@@ -22,11 +22,14 @@ export const getNetworkType = (chainId: number): NetworkType => {
   }
 };
 
-export const RAY_DECIMALS = 27;
-export const RAY = BigNumber.from(10).pow(RAY_DECIMALS);
+export const RAY_DECIMALS_POW = 27;
+export const RAY = BigNumber.from(10).pow(RAY_DECIMALS_POW);
 export const halfRAY = RAY.div(2);
-export const WAD_DECIMALS = 18;
-export const WAD = BigNumber.from(10).pow(WAD_DECIMALS);
+export const WAD_DECIMALS_POW = 18;
+export const WAD = BigNumber.from(10).pow(WAD_DECIMALS_POW);
+
+export const PRICE_DECIMALS_POW = 8;
+export const PRICE_DECIMALS = BigNumber.from(10).pow(PRICE_DECIMALS_POW);
 
 export const SECONDS_PER_YEAR = 365 * 24 * 3600;
 
@@ -45,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

@@ -3,9 +3,14 @@ import {
   CreditAccountDataExtendedPayload,
   CreditAccountDataPayload
 } from "../payload/creditAccount";
-import { PERCENTAGE_FACTOR, RAY, PERCENTAGE_DECIMALS } from "./constants";
+import {
+  PERCENTAGE_FACTOR,
+  RAY,
+  PERCENTAGE_DECIMALS,
+  PRICE_DECIMALS
+} from "./constants";
 import { TokenData } from "../tokens/tokenData";
-import { priceCalc } from "./price";
+import { calcTotalPrice } from "./price";
 
 export type Balance = { address: string; balance: BigNumber };
 
@@ -13,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) {
@@ -62,12 +81,10 @@ export class CreditAccountData {
   }
 
   balancesSorted(
-    prices: Record<string, number>,
+    prices: Record<string, BigNumber>,
     tokens: Record<string, TokenData>
   ): Array<Balance> {
-    const safeBalances = this.balances || [];
-
-    return sortBalances(safeBalances, prices, tokens).map(
+    return sortBalances(this.balances, prices, tokens).map(
       ([address, balance]) => ({ address, balance })
     );
   }
@@ -75,7 +92,7 @@ export class CreditAccountData {
 
 export function sortBalances(
   balances: Record<string, BigNumber>,
-  prices: Record<string, number>,
+  prices: Record<string, BigNumber>,
   tokens: Record<string, TokenData>
 ) {
   return Object.entries(balances).sort(([addr1, amount1], [addr2, amount2]) => {
@@ -85,17 +102,21 @@ export function sortBalances(
     const token1 = tokens[addr1Lc];
     const token2 = tokens[addr2Lc];
 
-    const price1 = prices[addr1Lc] || 1;
-    const price2 = prices[addr2Lc] || 1;
+    const price1 = prices[addr1Lc] || PRICE_DECIMALS;
+    const price2 = prices[addr2Lc] || PRICE_DECIMALS;
+
+    const totalPrice1 = calcTotalPrice(price1, amount1, token1?.decimals);
+    const totalPrice2 = calcTotalPrice(price2, amount2, token2?.decimals);
+
+    if (totalPrice1.eq(totalPrice2)) {
+      return tokensAbcComparator(token1, token2);
+    }
 
-    const assetValue1 = priceCalc(price1, amount1, token1);
-    const assetValue2 = priceCalc(price2, amount2, token2);
+    if (totalPrice1.gt(totalPrice2)) {
+      return -1;
+    }
 
-    return assetValue1.eq(assetValue2)
-      ? tokensAbcComparator(token1, token2)
-      : assetValue1.gt(assetValue2)
-      ? -1
-      : 1;
+    return 1;
   });
 }
 
@@ -108,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;
@@ -74,16 +93,17 @@ export class CreditManagerData {
       {}
     );
 
-    this.liquidationThresholds = payload.liquidationThresholds.reduce<
+    this.liquidationThresholds = (payload.liquidationThresholds || []).reduce<
       Record<string, BigNumber>
     >((acc, threshold, index) => {
       const address = payload.collateralTokens[index];
 
-      if (address) acc[address.toLowerCase()] = threshold;
+      if (address) acc[address.toLowerCase()] = BigNumber.from(threshold);
 
       return acc;
     }, {});
-    this.version = payload.version || 1;
+
+    this.version = BigNumber.from(payload.version || 1).toNumber();
     this.creditFacade = payload.creditFacade || "";
     this.isDegenMode = payload.isDegenMode || false;
     this.degenNFT = payload.degenNFT || "";
@@ -91,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);
   }
@@ -228,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");