@gearbox-protocol/sdk 0.0.100 → 0.0.103

package/src/tokens/token.ts

@@ -1,4 +1,9 @@
-import { keyToLowercase, objectEntries, swapKeyValue } from "../utils/mappers";
+import {
+  keyToLowercase,
+  objectEntries,
+  swapKeyValue,
+  filterEmptyKeys
+} from "../utils/mappers";
 import { NetworkType } from "../core/constants";
 import { NormalToken, NormalTokenData, normalTokens } from "./normal";
 import {
@@ -134,7 +139,7 @@ export const tokenDataByNetwork: Record<
     yvCurve_stETH: "0xdCD90C7f6324cfa40d7169ef80b12031770B4325",
     yvCurve_FRAX: "0xB4AdA607B9d6b2c9Ee07A275e9616B84AC560139",
 
-    //GEARBOX
+    // GEARBOX
     dDAI: "0x6CFaF95457d7688022FC53e7AbE052ef8DFBbdBA",
     dUSDC: "0xc411dB5f5Eb3f7d552F9B8454B2D74097ccdE6E3",
     dWBTC: "0xe753260F1955e8678DCeA8887759e07aa57E8c54",
@@ -212,11 +217,11 @@ export const tokenDataByNetwork: Record<
     stkcvxsteCRV: "0xd8bAbB7EfBF7F931a69B209f71b27421F8b18516",
     stkcvxcrvPlain3andSUSD: "0x6b45Cab756B41a7204973b71362ef5F73E67F6DA",
 
-    //GEARBOX
-    dDAI: "0x0d06D2e31781A0585feE334F63beF43543496e5d",
-    dUSDC: "0xcCc83353856A79c94EaDa39Df76B9c7C4c762dBF",
-    dWBTC: "0x4cCb374472C8c73b067c8c40b9420a221Ef014ca",
-    dWETH: "0x3B1e0Db6C960b32beEDf82af9db2da63F15Ba01E",
+    // GEARBOX
+    dDAI: "0x077a3Ce0D572b72436F6644793Fc7721353aF1f4",
+    dUSDC: "0x8147e00456c8A3128182730bFFdFd9D1E6bbC048",
+    dWBTC: "0x34D9B3c13B25632879B2DaabBde702F612902238",
+    dWETH: "0x19e4F905749D3b487CA4927b54e55b64625a1143",
 
     GEAR: "0xe01c5d0297c56e992dab3886057a1441485ff7c7"
   }
@@ -224,6 +229,10 @@ export const tokenDataByNetwork: Record<
 
 export const tokenSymbolByAddress = objectEntries(tokenDataByNetwork).reduce<
   Record<string, SupportedToken>
->((sum, [_, tokens]) => {
-  return { ...sum, ...keyToLowercase(swapKeyValue(tokens)) };
-}, {});
+>(
+  (acc, [, tokens]) => ({
+    ...acc,
+    ...filterEmptyKeys(keyToLowercase(swapKeyValue(tokens)))
+  }),
+  {}
+);

package/src/tokens/tokenData.ts

@@ -4,22 +4,32 @@ import { STATIC_TOKEN } from "../config";
 import { NetworkType } from "../core/constants";
 import { SupportedToken, tokenDataByNetwork } from "./token";
 
+type SymbolReplacements = Record<string, string>;
+const defaultSymbolReplacement: SymbolReplacements = {
+  dWETH: "dETH",
+  WETH: "ETH"
+};
+
 export class TokenData {
   public readonly id: string;
+
   // public readonly name: string;
   public readonly symbol: string;
+
   public readonly address: string;
+
   public readonly decimals: number;
+
   public readonly icon?: string;
 
-  constructor(payload: TokenDataPayload) {
+  constructor(
+    payload: TokenDataPayload,
+    symbolReplacements: SymbolReplacements = defaultSymbolReplacement
+  ) {
     this.id = payload.addr;
     this.address = payload.addr;
     // this.name = payload.name;
-    this.symbol = payload.symbol;
-    if (this.symbol === "WETH" || this.symbol === "dWETH") {
-      this.symbol = this.symbol.replace("WETH", "ETH");
-    }
+    this.symbol = symbolReplacements[payload.symbol] || payload.symbol;
     this.decimals = payload.decimals;
     this.icon = `${STATIC_TOKEN}${payload.symbol?.toLowerCase()}.svg`;
   }
@@ -41,7 +51,7 @@ export interface TokenAllowance {
 
 export const WETHToken: Record<NetworkType, string> = {
   Mainnet: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-  Kovan: "0xd0a1e359811322d97991e03f863a0c30c2cf029c",
+  Kovan: "0xd0a1e359811322d97991e03f863a0c30c2cf029c"
 };
 
 export const connectors: Record<NetworkType, Array<SupportedToken>> = {
@@ -51,7 +61,7 @@ export const connectors: Record<NetworkType, Array<SupportedToken>> = {
     "DAI",
     "USDC",
     // "USDT",
-    "WBTC",
+    "WBTC"
     // "stETH",
     // "PAX",
     // "TUSD",
@@ -59,11 +69,11 @@ export const connectors: Record<NetworkType, Array<SupportedToken>> = {
     // "BAL",
     // "sUSD",
   ],
-  Kovan: ["WETH", "DAI", "USDC", "WBTC"],
+  Kovan: ["WETH", "DAI", "USDC", "WBTC"]
 };
 
 export function getConnectors(networkType: NetworkType) {
-  return connectors[networkType].map((e) => {
+  return connectors[networkType].map(e => {
     const result =
       e === "WETH"
         ? WETHToken[networkType]

package/src/tokens/tokenType.ts

@@ -1,12 +1,12 @@
 export enum TokenType {
-    CONNECTOR,
-    NORMAL_TOKEN,
-    CURVE_LP,
-    META_CURVE_LP,
-    YEARN_VAULT,
-    YEARN_VAULT_OF_CURVE_LP,
-    YEARN_VAULT_OF_META_CURVE_LP,
-    CONVEX_LP_TOKEN,
-    CONVEX_STAKED_PHANTOM_TOKEN,
-    DIESEL_LP_TOKEN
-}
+  CONNECTOR,
+  NORMAL_TOKEN,
+  CURVE_LP,
+  META_CURVE_LP,
+  YEARN_VAULT,
+  YEARN_VAULT_OF_CURVE_LP,
+  YEARN_VAULT_OF_META_CURVE_LP,
+  CONVEX_LP_TOKEN,
+  CONVEX_STAKED_PHANTOM_TOKEN,
+  DIESEL_LP_TOKEN
+}

package/src/tokens/yearn.ts

@@ -1,137 +1,139 @@
-import {TradeAction, TradeType} from "../pathfinder/tradeTypes";
-import {TokenBase} from "./token";
-import {CurveLPToken} from "./curveLP";
-import {NormalToken} from "./normal";
-import {TokenType} from "./tokenType";
+import { TradeAction, TradeType } from "../pathfinder/tradeTypes";
+import type { TokenBase } from "./token";
+import type { CurveLPToken } from "./curveLP";
+import type { NormalToken } from "./normal";
+import { TokenType } from "./tokenType";
 
 export type YearnLPToken =
-    | "yvDAI"
-    | "yvUSDC"
-    | "yvWETH"
-    | "yvWBTC"
-    | "yvCurve_stETH"
-    | "yvCurve_FRAX";
+  | "yvDAI"
+  | "yvUSDC"
+  | "yvWETH"
+  | "yvWBTC"
+  | "yvCurve_stETH"
+  | "yvCurve_FRAX";
 
 export type YearnVaultTokenData = {
-    symbol: YearnLPToken;
-    type: TokenType.YEARN_VAULT;
-    underlying: NormalToken;
-    lpActions: Array<TradeAction>;
+  symbol: YearnLPToken;
+  type: TokenType.YEARN_VAULT;
+  underlying: NormalToken;
+  lpActions: Array<TradeAction>;
 } & TokenBase;
 
 export type YearnVaultOfCurveLPTokenData = {
-    symbol: YearnLPToken;
-    type: TokenType.YEARN_VAULT_OF_CURVE_LP;
-    underlying: CurveLPToken;
-    lpActions: Array<TradeAction>;
+  symbol: YearnLPToken;
+  type: TokenType.YEARN_VAULT_OF_CURVE_LP;
+  underlying: CurveLPToken;
+  lpActions: Array<TradeAction>;
 } & TokenBase;
 
 export type YearnVaultOfMetaCurveLPTokenData = {
-    symbol: YearnLPToken;
-    type: TokenType.YEARN_VAULT_OF_META_CURVE_LP;
-    underlying: CurveLPToken;
-    lpActions: Array<TradeAction>;
+  symbol: YearnLPToken;
+  type: TokenType.YEARN_VAULT_OF_META_CURVE_LP;
+  underlying: CurveLPToken;
+  lpActions: Array<TradeAction>;
 } & TokenBase;
 
-export const yearnTokens: Record<YearnLPToken,
-    | YearnVaultTokenData
-    | YearnVaultOfCurveLPTokenData
-    | YearnVaultOfMetaCurveLPTokenData> = {
-    // YEARN TOKENS
-    yvDAI: {
-        name: "yvDAI",
-        decimals: 18,
-
-        symbol: "yvDAI",
-        type: TokenType.YEARN_VAULT,
-        underlying: "DAI",
-        lpActions: [
-            {
-                type: TradeType.YearnWithdraw,
-                contract: "YEARN_DAI_VAULT",
-                tokenOut: "DAI"
-            }
-        ]
-    },
-
-    yvUSDC: {
-        name: "yvUSDC",
-        decimals: 6,
-
-        symbol: "yvUSDC",
-        type: TokenType.YEARN_VAULT,
-        underlying: "USDC",
-        lpActions: [
-            {
-                type: TradeType.YearnWithdraw,
-                contract: "YEARN_USDC_VAULT",
-                tokenOut: "USDC"
-            }
-        ]
-    },
-
-    yvWETH: {
-        name: "yvWETH",
-        decimals: 18,
-
-        symbol: "yvWETH",
-        type: TokenType.YEARN_VAULT,
-        underlying: "WETH",
-        lpActions: [
-            {
-                type: TradeType.YearnWithdraw,
-                contract: "YEARN_WETH_VAULT",
-                tokenOut: "WETH"
-            }
-        ]
-    },
-
-    yvWBTC: {
-        name: "yvWBTC",
-        decimals: 8,
-
-        symbol: "yvWBTC",
-        type: TokenType.YEARN_VAULT,
-        underlying: "WBTC",
-        lpActions: [
-            {
-                type: TradeType.YearnWithdraw,
-                contract: "YEARN_WBTC_VAULT",
-                tokenOut: "WBTC"
-            }
-        ]
-    },
-
-    // YEARN- CURVE TOKENS
-    yvCurve_stETH: {
-        name: "yvCurve-stETH",
-        decimals: 18,
-
-        symbol: "yvCurve_stETH",
-        type: TokenType.YEARN_VAULT_OF_CURVE_LP,
-        underlying: "steCRV",
-        lpActions: [
-            {
-                type: TradeType.YearnWithdraw,
-                contract: "YEARN_CURVE_STETH_VAULT",
-                tokenOut: "steCRV"
-            }
-        ]
-    },
-
-    yvCurve_FRAX: {
-        name: "yvCurve-FRAX",
-        decimals: 18,
-
-        symbol: "yvCurve_FRAX",
-        type: TokenType.YEARN_VAULT_OF_META_CURVE_LP,
-        underlying: "FRAX3CRV",
-        lpActions: [
-            {
-                type: TradeType.YearnWithdraw,
-                contract: "YEARN_CURVE_FRAX_VAULT",
-                tokenOut: "FRAX3CRV"
-            }
-        ]
-    }
+export const yearnTokens: Record<
+  YearnLPToken,
+  | YearnVaultTokenData
+  | YearnVaultOfCurveLPTokenData
+  | YearnVaultOfMetaCurveLPTokenData
+> = {
+  // YEARN TOKENS
+  yvDAI: {
+    name: "yvDAI",
+    decimals: 18,
+
+    symbol: "yvDAI",
+    type: TokenType.YEARN_VAULT,
+    underlying: "DAI",
+    lpActions: [
+      {
+        type: TradeType.YearnWithdraw,
+        contract: "YEARN_DAI_VAULT",
+        tokenOut: "DAI"
+      }
+    ]
+  },
+
+  yvUSDC: {
+    name: "yvUSDC",
+    decimals: 6,
+
+    symbol: "yvUSDC",
+    type: TokenType.YEARN_VAULT,
+    underlying: "USDC",
+    lpActions: [
+      {
+        type: TradeType.YearnWithdraw,
+        contract: "YEARN_USDC_VAULT",
+        tokenOut: "USDC"
+      }
+    ]
+  },
+
+  yvWETH: {
+    name: "yvWETH",
+    decimals: 18,
+
+    symbol: "yvWETH",
+    type: TokenType.YEARN_VAULT,
+    underlying: "WETH",
+    lpActions: [
+      {
+        type: TradeType.YearnWithdraw,
+        contract: "YEARN_WETH_VAULT",
+        tokenOut: "WETH"
+      }
+    ]
+  },
+
+  yvWBTC: {
+    name: "yvWBTC",
+    decimals: 8,
+
+    symbol: "yvWBTC",
+    type: TokenType.YEARN_VAULT,
+    underlying: "WBTC",
+    lpActions: [
+      {
+        type: TradeType.YearnWithdraw,
+        contract: "YEARN_WBTC_VAULT",
+        tokenOut: "WBTC"
+      }
+    ]
+  },
+
+  // YEARN- CURVE TOKENS
+  yvCurve_stETH: {
+    name: "yvCurve-stETH",
+    decimals: 18,
+
+    symbol: "yvCurve_stETH",
+    type: TokenType.YEARN_VAULT_OF_CURVE_LP,
+    underlying: "steCRV",
+    lpActions: [
+      {
+        type: TradeType.YearnWithdraw,
+        contract: "YEARN_CURVE_STETH_VAULT",
+        tokenOut: "steCRV"
+      }
+    ]
+  },
+
+  yvCurve_FRAX: {
+    name: "yvCurve-FRAX",
+    decimals: 18,
+
+    symbol: "yvCurve_FRAX",
+    type: TokenType.YEARN_VAULT_OF_META_CURVE_LP,
+    underlying: "FRAX3CRV",
+    lpActions: [
+      {
+        type: TradeType.YearnWithdraw,
+        contract: "YEARN_CURVE_FRAX_VAULT",
+        tokenOut: "FRAX3CRV"
+      }
+    ]
+  }
 };

package/src/utils/errors.ts

@@ -0,0 +1,11 @@
+interface IMetamaskError {
+  code: number;
+  message: string;
+}
+
+export const isMetamaskError = (e: any): e is IMetamaskError => {
+  if (!e) return false;
+  if (typeof e !== "object") return false;
+  if (typeof e.code !== "number" || typeof e.message !== "string") return false;
+  return true;
+};

package/src/utils/formatter.ts

@@ -1,6 +1,6 @@
 import { BigNumber, BigNumberish } from "ethers";
-import { PERCENTAGE_FACTOR, RAY } from "../core/constants";
 import Decimal from "decimal.js-light";
+import { PERCENTAGE_FACTOR, RAY, LEVERAGE_DECIMALS } from "../core/constants";
 
 export function rayToNumber(num: BigNumberish): number {
   return (
@@ -13,10 +13,13 @@ export function formatRAY(num?: BigNumber): string {
 }
 
 export function formatBN(
-  num: BigNumberish | undefined,
+  numArg: BigNumberish | undefined,
   decimals: number,
-  precision?: number
+  precisionArg?: number
 ): string {
+  let num = numArg;
+  let precision = precisionArg;
+
   if (!num) return "-";
 
   // if (BigNumber.from(num).gt(BigNumber.from(10).pow(37))) {
@@ -64,23 +67,24 @@ export function formatBn4dig(num: BigNumber, precision: number = 2): string {
   let numStr = num.toString();
   if (numStr.length < 6) numStr = "0".repeat(6 - numStr.length) + numStr;
   return numStr.length <= 6
-    ? "0." + numStr.slice(0, precision)
-    : numStr.slice(0, numStr.length - 6) +
-        "." +
-        numStr.slice(numStr.length - 6, numStr.length - 6 + precision);
+    ? `0.${numStr.slice(0, precision)}`
+    : `${numStr.slice(0, numStr.length - 6)}.${numStr.slice(
+        numStr.length - 6,
+        numStr.length - 6 + precision
+      )}`;
 }
 
 export function toHumanFormat(num: BigNumber, precision: number = 2): string {
   if (num.gte(1e15)) {
-    return formatBn4dig(num.div(1e9), precision) + "Bn";
+    return `${formatBn4dig(num.div(1e9), precision)}Bn`;
   }
 
   if (num.gte(1e12)) {
-    return formatBn4dig(num.div(1e6), precision) + "M";
+    return `${formatBn4dig(num.div(1e6), precision)}M`;
   }
 
   if (num.gte(1e9)) {
-    return formatBn4dig(num.div(1e3), precision) + "K";
+    return `${formatBn4dig(num.div(1e3), precision)}K`;
   }
 
   return formatBn4dig(num, precision);
@@ -112,23 +116,23 @@ export function shortHash(address?: string): string {
 
 export const formatRate = (rate: BigNumberish | undefined) =>
   rate
-    ? (
+    ? `${(
         BigNumber.from(rate)
           .mul(PERCENTAGE_FACTOR)
           .mul(100)
           .div(RAY)
           .toNumber() / PERCENTAGE_FACTOR
-      ).toFixed(2) + "%"
+      ).toFixed(2)}%`
     : "0.00%";
 
 export function formatDate(date: Date): string {
-  var d = new Date(date),
-    month = "" + (d.getMonth() + 1),
-    day = "" + d.getDate(),
-    year = d.getFullYear();
+  const d = new Date(date);
+  let month = `${d.getMonth() + 1}`;
+  let day = `${d.getDate()}`;
+  const year = d.getFullYear();
 
-  if (month.length < 2) month = "0" + month;
-  if (day.length < 2) day = "0" + day;
+  if (month.length < 2) month = `0${month}`;
+  if (day.length < 2) day = `0${day}`;
 
   return [year, month, day].join("-");
 }
@@ -136,3 +140,7 @@ export function formatDate(date: Date): string {
 export function formatHf(healthFactor: number): string {
   return (healthFactor / 10000).toFixed(2);
 }
+
+export function formatLeverage(leverage: number, decimals: number = 2) {
+  return (leverage / LEVERAGE_DECIMALS).toFixed(decimals);
+}

package/src/utils/loading.ts

@@ -1,9 +1,17 @@
-export function loadingProgress(...params: Array<unknown>): number {
-  let isLoaded: number = 0;
+const isLoaded = (v: unknown) => v !== undefined;
 
-  for (const item of params) {
-    if (item !== undefined) isLoaded++;
-  }
+export function allLoaded(itemsToLoad: Array<unknown>): boolean {
+  return itemsToLoad.reduce<boolean>(
+    (acc, item) => acc && isLoaded(item),
+    true
+  );
+}
+
+export function loadingProgress(itemsToLoad: Array<unknown>): number {
+  const loaded = itemsToLoad.reduce<number>(
+    (acc, item) => (isLoaded(item) ? acc + 1 : acc),
+    0
+  );
 
-  return Math.floor((isLoaded / params.length) * 100);
+  return Math.floor((loaded / itemsToLoad.length) * 100);
 }

package/src/utils/mappers.ts

@@ -7,17 +7,26 @@ const objectEntries = <K extends SupportedValue, T>(
 const swapKeyValue = <K extends SupportedValue, T extends SupportedValue>(
   o: Record<K, T>
 ): Record<T, K> =>
-  objectEntries(o).reduce((sum, [key, value]) => {
-    return { ...sum, [value]: key };
-  }, {} as Record<T, K>);
+  objectEntries(o).reduce(
+    (acc, [key, value]) => ({ ...acc, [value]: key }),
+    {} as Record<T, K>
+  );
 
 const keyToLowercase = <K extends SupportedValue, T extends SupportedValue>(
   o: Record<K, T>
 ): Record<K, T> =>
-  objectEntries(o).reduce((sum, [key, value]) => {
+  objectEntries(o).reduce((acc, [key, value]) => {
     const keyTransformed = typeof key === "string" ? key.toLowerCase() : key;
-    return { ...sum, [keyTransformed]: value };
+    return { ...acc, [keyTransformed]: value };
   }, {} as Record<K, T>);
 
+const filterEmptyKeys = <K extends SupportedValue, T extends SupportedValue>(
+  o: Record<K, T>
+): Record<K, T> =>
+  objectEntries(o).reduce(
+    (acc, [key, value]) => (key ? { ...acc, [key]: value } : acc),
+    {} as Record<K, T>
+  );
+
 export type { SupportedValue };
-export { objectEntries, swapKeyValue, keyToLowercase };
+export { objectEntries, swapKeyValue, keyToLowercase, filterEmptyKeys };

package/src/utils/multicall.ts

@@ -1,4 +1,5 @@
 import { ethers } from "ethers";
+import { MULTICALL_ADDRESS } from "../config";
 import { Multicall2, Multicall2__factory } from "../types";
 
 export interface CallData<T extends ethers.utils.Interface> {
@@ -17,10 +18,7 @@ export async function multicall<R extends Array<any>>(
   calls: Array<MCall<any>>,
   p: ethers.providers.Provider
 ): Promise<R> {
-  const multiCallContract = Multicall2__factory.connect(
-    "0x5ba1e12693dc8f9c48aad8770482f4739beed696",
-    p
-  );
+  const multiCallContract = Multicall2__factory.connect(MULTICALL_ADDRESS, p);
 
   const { returnData } = await multiCallContract.callStatic.aggregate(
     calls.map(c => ({
@@ -33,12 +31,14 @@ export async function multicall<R extends Array<any>>(
     .map((d, num) =>
       calls[num].interface.decodeFunctionResult(calls[num].method as string, d)
     )
-    .map(r => r[0]) as R;
+    .map(r => (Array.isArray(r) && r.length <= 1 ? r[0] : r)) as R;
 }
 
 export class MultiCallContract<T extends ethers.utils.Interface> {
   private readonly _address: string;
+
   private readonly _interface: T;
+
   protected _multiCall: Multicall2;
 
   constructor(
@@ -49,10 +49,7 @@ export class MultiCallContract<T extends ethers.utils.Interface> {
     this._address = address;
     this._interface = intrerface;
 
-    this._multiCall = Multicall2__factory.connect(
-      "0x5ba1e12693dc8f9c48aad8770482f4739beed696",
-      provider
-    );
+    this._multiCall = Multicall2__factory.connect(MULTICALL_ADDRESS, provider);
   }
 
   async call<R extends Array<any>>(data: Array<CallData<T>>): Promise<R> {

package/src/utils/network.ts

@@ -1,28 +1,28 @@
-import {ethers} from "ethers";
-import {tokenDataByNetwork} from "../tokens/token";
-import {ERC20__factory} from "../types";
-import {ADDRESS_0x0, NetworkType} from "../core/constants";
+import { ethers } from "ethers";
+import { tokenDataByNetwork } from "../tokens/token";
+import { ERC20__factory } from "../types";
+import { ADDRESS_0X0, NetworkType } from "../core/constants";
 
 export async function detectNetwork(
-    provider: ethers.providers.Provider
+  provider: ethers.providers.Provider
 ): Promise<NetworkType> {
+  try {
+    const usdcMainnet = ERC20__factory.connect(
+      tokenDataByNetwork.Mainnet.USDC,
+      provider
+    );
+    await usdcMainnet.balanceOf(ADDRESS_0X0);
+    return "Mainnet";
+  } catch {
     try {
-        const usdcMainnet = ERC20__factory.connect(
-            tokenDataByNetwork.Mainnet.USDC,
-            provider
-        );
-        await usdcMainnet.balanceOf(ADDRESS_0x0);
-        return "Mainnet";
+      const usdcMainnet = ERC20__factory.connect(
+        tokenDataByNetwork.Kovan.USDC,
+        provider
+      );
+      await usdcMainnet.balanceOf(ADDRESS_0X0);
+      return "Kovan";
     } catch {
-        try {
-            const usdcMainnet = ERC20__factory.connect(
-                tokenDataByNetwork.Kovan.USDC,
-                provider
-            );
-            await usdcMainnet.balanceOf(ADDRESS_0x0);
-            return "Kovan";
-        } catch {
-            throw new Error("Unknown network");
-        }
+      throw new Error("Unknown network");
     }
+  }
 }