@gearbox-protocol/sdk 0.0.98 → 0.0.101

package/lib/tokens/token.js

@@ -141,12 +141,12 @@ exports.tokenDataByNetwork = {
         cvxsteCRV: "0xb22c2015327cfbeD480eF45B6382d4bC963a4595",
         cvxcrvPlain3andSUSD: "0xBBeAdEA3C648cF4026d0422EAF2463050202700b",
         cvxFRAX3CRV: "0xBC523005975D86de9226785DD83e4f8d2A87fA73",
-        cvxLUSD3CRV: "0xF1128521595A6CAee02af9DBdb15857954cC2cA0",
+        cvxLUSD3CRV: "0xF90d9a96985a80e6c2cA9952cd2C6Db5B720408F",
         cvxgusd3CRV: "0xa3aDFDf18d166e26bF1Bc0ee63D26d0d1064b056",
         // CONVEX PHANTOM TOKEN ADDRESSES
         stkcvx3Crv: "0xf4FC4Aa052346fEa87f1e864f10de0f7383e9502",
         stkcvxFRAX3CRV: "0xd726f9684245065B120E1ac18de389f6b05351Ba",
-        stkcvxLUSD3CRV: "",
+        stkcvxLUSD3CRV: "0x5c355c46413B45Cc58aB61AcaF5BB72E7c2d1465",
         stkcvxgusd3CRV: "0x9A74e8106f6c28b21b1B6a0F985cf1227BE05F04",
         stkcvxsteCRV: "0xd8bAbB7EfBF7F931a69B209f71b27421F8b18516",
         stkcvxcrvPlain3andSUSD: "0x6b45Cab756B41a7204973b71362ef5F73E67F6DA",
@@ -158,7 +158,7 @@ exports.tokenDataByNetwork = {
         GEAR: "0xe01c5d0297c56e992dab3886057a1441485ff7c7"
     }
 };
-exports.tokenSymbolByAddress = (0, mappers_1.objectEntries)(exports.tokenDataByNetwork).reduce(function (sum, _a) {
+exports.tokenSymbolByAddress = (0, mappers_1.objectEntries)(exports.tokenDataByNetwork).reduce(function (acc, _a) {
     var _ = _a[0], tokens = _a[1];
-    return __assign(__assign({}, sum), (0, mappers_1.keyToLowercase)((0, mappers_1.swapKeyValue)(tokens)));
+    return __assign(__assign({}, acc), (0, mappers_1.filterEmptyKeys)((0, mappers_1.keyToLowercase)((0, mappers_1.swapKeyValue)(tokens))));
 }, {});

package/lib/utils/formatter.d.ts

@@ -11,3 +11,4 @@ export declare function shortHash(address?: string): string;
 export declare const formatRate: (rate: BigNumberish | undefined) => string;
 export declare function formatDate(date: Date): string;
 export declare function formatHf(healthFactor: number): string;
+export declare function formatLeverage(leverage: number, decimals?: number): string;

package/lib/utils/formatter.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatHf = exports.formatDate = exports.formatRate = exports.shortHash = exports.shortAddress = exports.toBN = exports.toSignificant = exports.toHumanFormat = exports.formatBn4dig = exports.formatBN = exports.formatRAY = exports.rayToNumber = void 0;
+exports.formatLeverage = exports.formatHf = exports.formatDate = exports.formatRate = exports.shortHash = exports.shortAddress = exports.toBN = exports.toSignificant = exports.toHumanFormat = exports.formatBn4dig = exports.formatBN = exports.formatRAY = exports.rayToNumber = void 0;
 var ethers_1 = require("ethers");
 var constants_1 = require("../core/constants");
 var decimal_js_light_1 = __importDefault(require("decimal.js-light"));
@@ -123,3 +123,8 @@ function formatHf(healthFactor) {
     return (healthFactor / 10000).toFixed(2);
 }
 exports.formatHf = formatHf;
+function formatLeverage(leverage, decimals) {
+    if (decimals === void 0) { decimals = 2; }
+    return (leverage / constants_1.LEVERAGE_DECIMALS).toFixed(decimals);
+}
+exports.formatLeverage = formatLeverage;

package/lib/utils/mappers.d.ts

@@ -2,5 +2,6 @@ declare type SupportedValue = string | number;
 declare const objectEntries: <K extends SupportedValue, T>(o: Record<K, T>) => [K, T][];
 declare const swapKeyValue: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<T, K>;
 declare const keyToLowercase: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<K, T>;
+declare const filterEmptyKeys: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<K, T>;
 export type { SupportedValue };
-export { objectEntries, swapKeyValue, keyToLowercase };
+export { objectEntries, swapKeyValue, keyToLowercase, filterEmptyKeys };

package/lib/utils/mappers.js

@@ -11,23 +11,31 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keyToLowercase = exports.swapKeyValue = exports.objectEntries = void 0;
+exports.filterEmptyKeys = exports.keyToLowercase = exports.swapKeyValue = exports.objectEntries = void 0;
 var objectEntries = function (o) { return Object.entries(o); };
 exports.objectEntries = objectEntries;
 var swapKeyValue = function (o) {
-    return objectEntries(o).reduce(function (sum, _a) {
+    return objectEntries(o).reduce(function (acc, _a) {
         var _b;
         var key = _a[0], value = _a[1];
-        return __assign(__assign({}, sum), (_b = {}, _b[value] = key, _b));
+        return __assign(__assign({}, acc), (_b = {}, _b[value] = key, _b));
     }, {});
 };
 exports.swapKeyValue = swapKeyValue;
 var keyToLowercase = function (o) {
-    return objectEntries(o).reduce(function (sum, _a) {
+    return objectEntries(o).reduce(function (acc, _a) {
         var _b;
         var key = _a[0], value = _a[1];
         var keyTransformed = typeof key === "string" ? key.toLowerCase() : key;
-        return __assign(__assign({}, sum), (_b = {}, _b[keyTransformed] = value, _b));
+        return __assign(__assign({}, acc), (_b = {}, _b[keyTransformed] = value, _b));
     }, {});
 };
 exports.keyToLowercase = keyToLowercase;
+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;
+    }, {});
+};
+exports.filterEmptyKeys = filterEmptyKeys;

package/lib/utils/multicall.js

@@ -37,6 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiCallContract = exports.multicall = void 0;
+var config_1 = require("../config");
 var types_1 = require("../types");
 function multicall(calls, p) {
     return __awaiter(this, void 0, void 0, function () {
@@ -44,7 +45,7 @@ function multicall(calls, p) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    multiCallContract = types_1.Multicall2__factory.connect("0x5ba1e12693dc8f9c48aad8770482f4739beed696", p);
+                    multiCallContract = types_1.Multicall2__factory.connect(config_1.MULTICALL_ADDRESS, p);
                     return [4 /*yield*/, multiCallContract.callStatic.aggregate(calls.map(function (c) { return ({
                             target: c.address,
                             callData: c.interface.encodeFunctionData(c.method, c.params)
@@ -55,7 +56,7 @@ function multicall(calls, p) {
                             .map(function (d, num) {
                             return calls[num].interface.decodeFunctionResult(calls[num].method, d);
                         })
-                            .map(function (r) { return r[0]; })];
+                            .map(function (r) { return (Array.isArray(r) && r.length <= 1 ? r[0] : r); })];
             }
         });
     });
@@ -65,7 +66,7 @@ var MultiCallContract = /** @class */ (function () {
     function MultiCallContract(address, intrerface, provider) {
         this._address = address;
         this._interface = intrerface;
-        this._multiCall = types_1.Multicall2__factory.connect("0x5ba1e12693dc8f9c48aad8770482f4739beed696", provider);
+        this._multiCall = types_1.Multicall2__factory.connect(config_1.MULTICALL_ADDRESS, provider);
     }
     MultiCallContract.prototype.call = function (data) {
         return __awaiter(this, void 0, void 0, function () {

package/lib/utils/types.d.ts

@@ -1,3 +1,4 @@
 export declare type PartialRecord<K extends keyof any, T> = {
     [P in K]?: T;
 };
+export declare type AwaitedRes<T extends (...args: any) => any> = Awaited<ReturnType<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "0.0.98",
+  "version": "0.0.101",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

package/src/apy/convexAPY.ts

@@ -0,0 +1,249 @@
+import { BigNumber, providers } from "ethers";
+import axios from "axios";
+import {
+  ConvexPoolContract,
+  ConvexPoolParams,
+  contractsByNetwork,
+  contractParams,
+  CurvePoolContract
+} from "../contracts/contracts";
+
+import { tokenDataByNetwork, supportedTokens } from "../tokens/token";
+import { CurveLPToken } from "../tokens/curveLP";
+import { ConvexPhantomTokenData } from "../tokens/convex";
+
+import {
+  IBaseRewardPool__factory,
+  IBaseRewardPool,
+  IConvexToken__factory,
+  IConvexToken,
+  CurveV1AdapterStETH,
+  CurveV1AdapterStETH__factory
+} from "../types";
+
+import { multicall, MCall } from "../utils/multicall";
+import { toBN } from "../utils/formatter";
+import { AwaitedRes } from "../utils/types";
+
+import {
+  SECONDS_PER_YEAR,
+  WAD,
+  WAD_DECIMALS,
+  NetworkType
+} from "../core/constants";
+
+type SupportedPools = Extract<
+  ConvexPoolContract,
+  | "CONVEX_3CRV_POOL"
+  | "CONVEX_FRAX3CRV_POOL"
+  | "CONVEX_LUSD3CRV_POOL"
+  | "CONVEX_GUSD_POOL"
+  | "CONVEX_SUSD_POOL"
+>;
+
+type SupportedConvex = Extract<
+  CurvePoolContract,
+  | "CURVE_3CRV_POOL"
+  | "CURVE_FRAX_POOL"
+  | "CURVE_LUSD_POOL"
+  | "CURVE_GUSD_POOL"
+  | "CURVE_SUSD_POOL"
+>;
+
+const curveSwapByPool: Record<SupportedPools, SupportedConvex> = {
+  CONVEX_3CRV_POOL: "CURVE_3CRV_POOL",
+  CONVEX_FRAX3CRV_POOL: "CURVE_FRAX_POOL",
+  CONVEX_LUSD3CRV_POOL: "CURVE_LUSD_POOL",
+  CONVEX_GUSD_POOL: "CURVE_GUSD_POOL",
+  CONVEX_SUSD_POOL: "CURVE_SUSD_POOL"
+};
+
+export async function getConvexApy(
+  pool: SupportedPools,
+  provider: providers.Provider,
+  networkType: NetworkType,
+  getTokenPrice: (tokenAddress: string) => BigNumber
+) {
+  const tokenList = tokenDataByNetwork[networkType];
+  const contractsList = contractsByNetwork[networkType];
+
+  const poolParams = contractParams[pool] as ConvexPoolParams;
+  const stakedTokenParams = supportedTokens[
+    poolParams.stakedToken
+  ] as ConvexPhantomTokenData;
+
+  const underlying = stakedTokenParams.underlying;
+  const basePoolAddress = contractsList[pool];
+  const swapPoolAddress = contractsList[curveSwapByPool[pool]];
+  const cvxAddress = tokenList.CVX;
+
+  const extraPoolAddresses = poolParams.extraRewards.map(d => {
+    return d.poolAddress[networkType];
+  });
+
+  const [basePoolRate, basePoolSupply, vPrice, cvxSupply, ...extra] =
+    await getPoolData(
+      basePoolAddress,
+      swapPoolAddress,
+      cvxAddress,
+      extraPoolAddresses,
+      provider
+    );
+
+  const cvxPrice = getTokenPrice(tokenList["CVX"]);
+  const crvPrice = getTokenPrice(tokenList["CRV"]);
+
+  const crvPerSecond = basePoolRate;
+  const virtualSupply = basePoolSupply.mul(vPrice).div(WAD);
+  const crvPerUnderlying = crvPerSecond.mul(WAD).div(virtualSupply);
+
+  const crvPerYear = crvPerUnderlying.mul(SECONDS_PER_YEAR);
+  const cvxPerYear = getCVXMintAmount(crvPerYear, cvxSupply);
+
+  const crvAPY = crvPerYear.mul(cvxPrice).div(WAD);
+  const cvxAPY = cvxPerYear.mul(crvPrice).div(WAD);
+
+  const extraAPRs = await Promise.all(
+    extraPoolAddresses.map(async (_, index) => {
+      const extraRewardSymbol = poolParams.extraRewards[index].rewardToken;
+      const extraPoolRate = extra[index];
+
+      const perUnderlying = extraPoolRate.mul(WAD).div(virtualSupply);
+      const perYear = perUnderlying.mul(SECONDS_PER_YEAR);
+
+      const extraPrise = getTokenPrice(tokenList[extraRewardSymbol]);
+
+      const extraAPY = perYear.mul(extraPrise).div(WAD);
+
+      return extraAPY;
+    })
+  );
+
+  const extraAPYTotal = extraAPRs.reduce(
+    (acc, apy) => acc.add(apy),
+    BigNumber.from(0)
+  );
+
+  const baseApyRAY = await getCurveBaseApy(underlying);
+
+  return baseApyRAY.add(crvAPY).add(cvxAPY).add(extraAPYTotal);
+}
+
+const CVX_MAX_SUPPLY = WAD.mul(100000000);
+const CVX_REDUCTION_PER_CLIFF = BigNumber.from(100000);
+const CVX_TOTAL_CLIFFS = WAD.mul(1000);
+
+function getCVXMintAmount(crvAmount: BigNumber, cvxSupply: BigNumber) {
+  const currentCliff = cvxSupply.div(CVX_REDUCTION_PER_CLIFF);
+
+  if (currentCliff.lt(CVX_TOTAL_CLIFFS)) {
+    const remainingCliffs = CVX_TOTAL_CLIFFS.sub(currentCliff);
+
+    const mintedAmount = crvAmount.mul(remainingCliffs).div(CVX_TOTAL_CLIFFS);
+
+    const amountTillMax = CVX_MAX_SUPPLY.sub(cvxSupply);
+
+    return mintedAmount.gt(amountTillMax) ? amountTillMax : mintedAmount;
+  }
+
+  return BigNumber.from(0);
+}
+
+type IBaseRewardPoolInterface = IBaseRewardPool["interface"];
+type IConvexTokenInterface = IConvexToken["interface"];
+type CurveV1AdapterStETHInterface = CurveV1AdapterStETH["interface"];
+
+async function getPoolData(
+  basePoolAddress: string,
+  underlying: string,
+  cvxAddress: string,
+  extraPoolAddresses: string[],
+  provider: providers.Provider
+) {
+  const calls: [
+    MCall<IBaseRewardPoolInterface>,
+    MCall<IBaseRewardPoolInterface>,
+    MCall<CurveV1AdapterStETHInterface>,
+    MCall<IConvexTokenInterface>,
+    ...Array<MCall<IBaseRewardPoolInterface>>
+  ] = [
+    {
+      address: basePoolAddress,
+      interface: IBaseRewardPool__factory.createInterface(),
+      method: "rewardRate()"
+    },
+    {
+      address: basePoolAddress,
+      interface: IBaseRewardPool__factory.createInterface(),
+      method: "totalSupply()"
+    },
+    {
+      address: underlying,
+      interface: CurveV1AdapterStETH__factory.createInterface(),
+      method: "get_virtual_price()"
+    },
+    {
+      address: cvxAddress,
+      interface: IConvexToken__factory.createInterface(),
+      method: "totalSupply()"
+    },
+    ...extraPoolAddresses.map(
+      (extraPoolAddress): MCall<IBaseRewardPoolInterface> => ({
+        address: extraPoolAddress,
+        interface: IBaseRewardPool__factory.createInterface(),
+        method: "rewardRate()"
+      })
+    )
+  ];
+
+  return multicall<
+    [
+      AwaitedRes<IBaseRewardPool["rewardRate"]>,
+      AwaitedRes<IBaseRewardPool["totalSupply"]>,
+      AwaitedRes<CurveV1AdapterStETH["get_virtual_price"]>,
+      AwaitedRes<IConvexToken["totalSupply"]>,
+      ...Array<AwaitedRes<IBaseRewardPool["rewardRate"]>>
+    ]
+  >(calls, provider);
+}
+
+interface CurveAPRData {
+  baseApy: number;
+  crvApy: number;
+  crvBoost: number;
+  crvPrice: number;
+}
+
+interface APYResponse {
+  apys: Record<string, CurveAPRData>;
+}
+
+const curveLPTokenToPoolName: Record<CurveLPToken, string> = {
+  "3Crv": "3pool",
+  FRAX3CRV: "frax",
+  gusd3CRV: "gusd",
+  LUSD3CRV: "lusd",
+  crvPlain3andSUSD: "susdv2",
+  steCRV: "steth"
+};
+
+const RESPONSE_DECIMALS = 100;
+
+// https://www.convexfinance.com/api/curve-apys
+
+export async function getCurveBaseApy(
+  curveLPToken: CurveLPToken
+): Promise<BigNumber> {
+  const poolName = curveLPTokenToPoolName[curveLPToken];
+
+  try {
+    const url = "https://www.convexfinance.com/api/curve-apys";
+    const result = await axios.get<APYResponse>(url);
+
+    const { baseApy = 0 } = result.data.apys[poolName] || {};
+
+    return toBN((baseApy / RESPONSE_DECIMALS).toString(), WAD_DECIMALS);
+  } catch (e) {
+    return BigNumber.from(0);
+  }
+}

package/src/apy/lidoAPY.ts

@@ -0,0 +1,81 @@
+import { providers } from "ethers";
+
+import { multicall, MCall } from "../utils/multicall";
+
+import { WAD, SECONDS_PER_YEAR, NetworkType } from "../core/constants";
+
+import {
+  ILidoOracle__factory,
+  ILidoOracle,
+  IstETH__factory,
+  IstETH
+} from "../types";
+
+type ILidoOracleInterface = ILidoOracle["interface"];
+
+type IstETHInterface = IstETH["interface"];
+
+const lidoOracleAddress: Record<NetworkType, string> = {
+  Mainnet: "0x442af784A788A5bd6F42A01Ebe9F287a871243fb",
+  Kovan: ""
+};
+
+const lidoStEthAddress: Record<NetworkType, string> = {
+  Mainnet: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+  Kovan: ""
+};
+
+export async function getLidoApy(
+  provider: providers.Provider,
+  networkType: NetworkType
+) {
+  if (!lidoOracleAddress[networkType]) {
+    throw `No Lido APR oracle found on current network: ${networkType}`;
+  }
+  if (!lidoStEthAddress[networkType]) {
+    throw `No Lido stETH found on current network: ${networkType}`;
+  }
+
+  const [{ postTotalPooledEther, preTotalPooledEther, timeElapsed }, fee] =
+    await geLidoData(
+      lidoOracleAddress[networkType],
+      lidoStEthAddress[networkType],
+      provider
+    );
+
+  const lidoAPRRay = postTotalPooledEther
+    .sub(preTotalPooledEther)
+    .mul(SECONDS_PER_YEAR)
+    .mul(WAD)
+    .div(preTotalPooledEther.mul(timeElapsed));
+
+  return [lidoAPRRay, fee] as const;
+}
+
+async function geLidoData(
+  lidoOracleAddress: string,
+  stETHAddress: string,
+  provider: providers.Provider
+) {
+  const calls: [MCall<ILidoOracleInterface>, MCall<IstETHInterface>] = [
+    {
+      address: lidoOracleAddress,
+      interface: ILidoOracle__factory.createInterface(),
+      method: "getLastCompletedReportDelta()"
+    },
+    {
+      address: stETHAddress,
+      interface: IstETH__factory.createInterface(),
+      method: "getFee()"
+    }
+  ];
+
+  return multicall<
+    [
+      Awaited<ReturnType<ILidoOracle["getLastCompletedReportDelta"]>>,
+      Awaited<ReturnType<IstETH["getFee"]>>
+    ]
+  >(calls, provider);
+}
+
+export const LIDO_FEE_DECIMALS = 10000;

package/src/config.ts

@@ -1 +1,2 @@
-export const STATIC_TOKEN = "https://static.gearbox.fi/tokens/"
+export const STATIC_TOKEN = "https://static.gearbox.fi/tokens/";
+export const MULTICALL_ADDRESS = "0x5ba1e12693dc8f9c48aad8770482f4739beed696";

package/src/contracts/contracts.ts

@@ -3,7 +3,12 @@
  * 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 { keyToLowercase, objectEntries, swapKeyValue } from "../utils/mappers";
+import {
+  keyToLowercase,
+  objectEntries,
+  swapKeyValue,
+  filterEmptyKeys
+} from "../utils/mappers";
 import { AdapterInterface } from "./adapters";
 import { NetworkType } from "../core/constants";
 import { Protocols } from "./protocols";
@@ -122,7 +127,7 @@ export const contractsByNetwork: Record<
     CONVEX_STECRV_POOL: "0x25edfea00131DAF9b23a8E07720Eea2382d58E71",
     CONVEX_SUSD_POOL: "0xE9998a1c357dc62550f2ED72b736a7CaEB262823",
     CONVEX_FRAX3CRV_POOL: "0xEBE0A1B948eB83333906EB80eE4b87Ee0b5CC84f",
-    CONVEX_LUSD3CRV_POOL: "0xb099D099286CB7483dbc7D62b5C91656bd15DBF0",
+    CONVEX_LUSD3CRV_POOL: "0x493Bd59EEcFfCa1BF88611CEd478aA5b74427e06",
     CONVEX_GUSD_POOL: "0xE7370DA7FD3d511dAB095Dd7d10388653d5cDE21",
     CONVEX_CLAIM_ZAP: "0x1330C2E5Cd8c333683aE511550f82d25918FFdd5",
 
@@ -179,10 +184,16 @@ type ConvexParams = {
     | AdapterInterface.CONVEX_V1_CLAIM_ZAP;
 } & BaseContractParams;
 
-type ConvexPoolParams = {
+type ConvexExtraPoolParams = {
+  rewardToken: NormalToken;
+  poolAddress: Record<NetworkType, string>;
+};
+
+export type ConvexPoolParams = {
   protocol: Protocols.Convex;
   type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL;
   stakedToken: ConvexStakedPhantomToken;
+  extraRewards: Array<ConvexExtraPoolParams>;
 } & BaseContractParams;
 
 export type LidoParams = {
@@ -314,46 +325,85 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BOOSTER
   },
+  CONVEX_CLAIM_ZAP: {
+    name: "Convex ZAP",
+    protocol: Protocols.Convex,
+    type: AdapterInterface.CONVEX_V1_CLAIM_ZAP
+  },
+
   CONVEX_3CRV_POOL: {
     name: "Convex 3crv",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvx3Crv"
+    stakedToken: "stkcvx3Crv",
+    extraRewards: []
   },
   CONVEX_GUSD_POOL: {
     name: "Convex GUSD",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxgusd3CRV"
+    stakedToken: "stkcvxgusd3CRV",
+    extraRewards: []
   },
   CONVEX_SUSD_POOL: {
     name: "Convex SUSD",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxcrvPlain3andSUSD"
+    stakedToken: "stkcvxcrvPlain3andSUSD",
+    extraRewards: [
+      {
+        rewardToken: "SNX",
+        poolAddress: {
+          Mainnet: "0x81fCe3E10D12Da6c7266a1A169c4C96813435263",
+          Kovan: "0x26a535146557FA58FA37e3078FEAc523b554939C"
+        }
+      }
+    ]
   },
   CONVEX_STECRV_POOL: {
     name: "Convex STECRV",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxsteCRV"
+    stakedToken: "stkcvxsteCRV",
+    extraRewards: [
+      {
+        rewardToken: "LDO",
+        poolAddress: {
+          Mainnet: "0x008aEa5036b819B4FEAEd10b2190FBb3954981E8",
+          Kovan: "0xd0B1CC3B4839363b1eC92F35eF45794CB07B1183"
+        }
+      }
+    ]
   },
   CONVEX_FRAX3CRV_POOL: {
     name: "Convex FRAX3CRV",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxFRAX3CRV"
+    stakedToken: "stkcvxFRAX3CRV",
+    extraRewards: [
+      {
+        rewardToken: "FXS",
+        poolAddress: {
+          Mainnet: "0xcDEC6714eB482f28f4889A0c122868450CDBF0b0",
+          Kovan: "0x89869c2e79FC6EFf51e714F1239D53702B5CDFCD"
+        }
+      }
+    ]
   },
   CONVEX_LUSD3CRV_POOL: {
     name: "Convex LUSD3CRV",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxLUSD3CRV"
-  },
-  CONVEX_CLAIM_ZAP: {
-    name: "Convex ZAP",
-    protocol: Protocols.Convex,
-    type: AdapterInterface.CONVEX_V1_CLAIM_ZAP
+    stakedToken: "stkcvxLUSD3CRV",
+    extraRewards: [
+      {
+        rewardToken: "LQTY",
+        poolAddress: {
+          Mainnet: "0x55d59b791f06dc519B176791c4E037E8Cf2f6361",
+          Kovan: ""
+        }
+      }
+    ]
   },
 
   LIDO_STETH_GATEWAY: {
@@ -370,6 +420,9 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
 
 export const contractsByAddress = objectEntries(contractsByNetwork).reduce<
   Record<string, SupportedContract>
->((sum, [_, contracts]) => {
-  return { ...sum, ...keyToLowercase(swapKeyValue(contracts)) };
+>((acc, [_, contracts]) => {
+  return {
+    ...acc,
+    ...filterEmptyKeys(keyToLowercase(swapKeyValue(contracts)))
+  };
 }, {});

package/src/contracts/contractsRegister.ts

@@ -35,11 +35,11 @@ export const deployedContracts: Record<string, string> = {
 
 const contractNames = Object.entries(contractsByAddress).reduce<
   Record<string, string>
->((sum, [addr, cSymbol]) => {
+>((acc, [addr, cSymbol]) => {
   const params = contractParams[cSymbol];
-  if (!params) return sum;
+  if (!params) return acc;
 
-  return { ...sum, [addr]: params.name };
+  return { ...acc, [addr]: params.name };
 }, {});
 
 const contractsFullList = {

package/src/core/constants.ts

@@ -22,12 +22,15 @@ export const getNetworkType = (chainId: number): NetworkType => {
   }
 };
 
-export const RAY = BigNumber.from(10).pow(27);
+export const RAY_DECIMALS = 27;
+export const RAY = BigNumber.from(10).pow(RAY_DECIMALS);
 export const halfRAY = RAY.div(2);
-export const WAD = BigNumber.from(10).pow(18);
+export const WAD_DECIMALS = 18;
+export const WAD = BigNumber.from(10).pow(WAD_DECIMALS);
 
 export const SECONDS_PER_YEAR = 365 * 24 * 3600;
 
+export const PERCENTAGE_DECIMALS = 100;
 export const PERCENTAGE_FACTOR = 1e4;
 export const LIQUIDATION_DISCOUNTED_SUM = 9500;
 export const UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD = 9300;
@@ -37,8 +40,9 @@ export const timeRanges: Record<string, number> = {
   "1D": 3600 * 24,
   "1W": 3600 * 24 * 7,
   "1M": 3600 * 24 * 30,
-  "1Y": 3600 * 24 * 365,
+  "1Y": 3600 * 24 * 365
 };
 
 export const LEVERAGE_DECIMALS = 100;
+export const SLIPPAGE_DECIMALS = 100;
 export const ADDRESS_0x0 = "0x0000000000000000000000000000000000000000";