@gearbox-protocol/sdk 0.0.100 → 0.0.103

package/.eslintignore

@@ -0,0 +1,4 @@
+node_modules
+src/types
+.eslintrc.js
+*.d.ts

package/.eslintrc.js

@@ -0,0 +1,52 @@
+module.exports = {
+  root: true,
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    project: ["./tsconfig.json"],
+    tsconfigRootDir: __dirname
+  },
+  plugins: ["@typescript-eslint", "prettier"],
+  extends: [
+    "airbnb-base",
+    "airbnb-typescript/base",
+    "plugin:import/recommended",
+    "prettier"
+  ],
+  settings: {
+    "import/resolver": {
+      typescript: {},
+      node: {
+        extensions: [".js", ".jsx", ".ts", ".tsx"],
+        moduleDirectory: ["node_modules", "./"]
+      }
+    },
+    react: {
+      version: "detect"
+    }
+  },
+  rules: {
+    "prettier/prettier": "error",
+    "import/no-extraneous-dependencies": ["error", { devDependencies: true }],
+    "@typescript-eslint/no-use-before-define": [
+      "error",
+      {
+        functions: false,
+        classes: false
+      }
+    ],
+    "no-console": ["error", { allow: ["warn", "error", "debug"] }],
+    "@typescript-eslint/default-param-last": ["warn"],
+
+    "no-nested-ternary": ["warn"],
+    "@typescript-eslint/no-unused-vars": ["warn"],
+    "no-underscore-dangle": ["error", { allowAfterThis: true }],
+
+    "react/no-unused-prop-types": ["off"], // switch on when necessary
+    "max-classes-per-file": ["off"],
+    "react/jsx-props-no-spreading": ["off"],
+    "react/no-array-index-key": ["off"],
+    "react/require-default-props": ["off"],
+    "import/prefer-default-export": ["off"],
+    "react/jsx-no-useless-fragment": ["off"]
+  }
+};

package/.husky/pre-push

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+yarn prepush

package/lib/apy/convexAPY.d.ts

@@ -0,0 +1,8 @@
+import { BigNumber, providers } from "ethers";
+import { ConvexPoolContract } from "../contracts/contracts";
+import { CurveLPToken } from "../tokens/curveLP";
+import { NetworkType } from "../core/constants";
+declare type SupportedPools = Extract<ConvexPoolContract, "CONVEX_3CRV_POOL" | "CONVEX_FRAX3CRV_POOL" | "CONVEX_LUSD3CRV_POOL" | "CONVEX_GUSD_POOL" | "CONVEX_SUSD_POOL">;
+export declare function getConvexApy(pool: SupportedPools, provider: providers.Provider, networkType: NetworkType, getTokenPrice: (tokenAddress: string) => BigNumber): Promise<BigNumber>;
+export declare function getCurveBaseApy(curveLPToken: CurveLPToken): Promise<BigNumber>;
+export {};

package/lib/apy/convexAPY.js

@@ -0,0 +1,200 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurveBaseApy = exports.getConvexApy = void 0;
+var ethers_1 = require("ethers");
+var axios_1 = __importDefault(require("axios"));
+var contracts_1 = require("../contracts/contracts");
+var token_1 = require("../tokens/token");
+var types_1 = require("../types");
+var multicall_1 = require("../utils/multicall");
+var formatter_1 = require("../utils/formatter");
+var constants_1 = require("../core/constants");
+var curveSwapByPool = {
+    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"
+};
+function getConvexApy(pool, provider, networkType, getTokenPrice) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tokenList, contractsList, poolParams, stakedTokenParams, underlying, basePoolAddress, swapPoolAddress, cvxAddress, extraPoolAddresses, _a, basePoolRate, basePoolSupply, vPrice, cvxSupply, extra, cvxPrice, crvPrice, crvPerSecond, virtualSupply, crvPerUnderlying, crvPerYear, cvxPerYear, crvAPY, cvxAPY, extraAPRs, extraAPYTotal, baseApyRAY;
+        var _this = this;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    tokenList = token_1.tokenDataByNetwork[networkType];
+                    contractsList = contracts_1.contractsByNetwork[networkType];
+                    poolParams = contracts_1.contractParams[pool];
+                    stakedTokenParams = token_1.supportedTokens[poolParams.stakedToken];
+                    underlying = stakedTokenParams.underlying;
+                    basePoolAddress = contractsList[pool];
+                    swapPoolAddress = contractsList[curveSwapByPool[pool]];
+                    cvxAddress = tokenList.CVX;
+                    extraPoolAddresses = poolParams.extraRewards.map(function (d) { return d.poolAddress[networkType]; });
+                    return [4 /*yield*/, getPoolData(basePoolAddress, swapPoolAddress, cvxAddress, extraPoolAddresses, provider)];
+                case 1:
+                    _a = _b.sent(), basePoolRate = _a[0], basePoolSupply = _a[1], vPrice = _a[2], cvxSupply = _a[3], extra = _a.slice(4);
+                    cvxPrice = getTokenPrice(tokenList.CVX);
+                    crvPrice = getTokenPrice(tokenList.CRV);
+                    crvPerSecond = basePoolRate;
+                    virtualSupply = basePoolSupply.mul(vPrice).div(constants_1.WAD);
+                    crvPerUnderlying = crvPerSecond.mul(constants_1.WAD).div(virtualSupply);
+                    crvPerYear = crvPerUnderlying.mul(constants_1.SECONDS_PER_YEAR);
+                    cvxPerYear = getCVXMintAmount(crvPerYear, cvxSupply);
+                    crvAPY = crvPerYear.mul(cvxPrice).div(constants_1.PRICE_DECIMALS);
+                    cvxAPY = cvxPerYear.mul(crvPrice).div(constants_1.PRICE_DECIMALS);
+                    return [4 /*yield*/, Promise.all(extraPoolAddresses.map(function (_, index) { return __awaiter(_this, void 0, void 0, function () {
+                            var extraRewardSymbol, extraPoolRate, perUnderlying, perYear, extraPrise, extraAPY;
+                            return __generator(this, function (_a) {
+                                extraRewardSymbol = poolParams.extraRewards[index].rewardToken;
+                                extraPoolRate = extra[index];
+                                perUnderlying = extraPoolRate.mul(constants_1.WAD).div(virtualSupply);
+                                perYear = perUnderlying.mul(constants_1.SECONDS_PER_YEAR);
+                                extraPrise = getTokenPrice(tokenList[extraRewardSymbol]);
+                                extraAPY = perYear.mul(extraPrise).div(constants_1.PRICE_DECIMALS);
+                                return [2 /*return*/, extraAPY];
+                            });
+                        }); }))];
+                case 2:
+                    extraAPRs = _b.sent();
+                    extraAPYTotal = extraAPRs.reduce(function (acc, apy) { return acc.add(apy); }, ethers_1.BigNumber.from(0));
+                    return [4 /*yield*/, getCurveBaseApy(underlying)];
+                case 3:
+                    baseApyRAY = _b.sent();
+                    return [2 /*return*/, baseApyRAY.add(crvAPY).add(cvxAPY).add(extraAPYTotal)];
+            }
+        });
+    });
+}
+exports.getConvexApy = getConvexApy;
+var CVX_MAX_SUPPLY = constants_1.WAD.mul(100000000);
+var CVX_REDUCTION_PER_CLIFF = ethers_1.BigNumber.from(100000);
+var CVX_TOTAL_CLIFFS = constants_1.WAD.mul(1000);
+function getCVXMintAmount(crvAmount, cvxSupply) {
+    var currentCliff = cvxSupply.div(CVX_REDUCTION_PER_CLIFF);
+    if (currentCliff.lt(CVX_TOTAL_CLIFFS)) {
+        var remainingCliffs = CVX_TOTAL_CLIFFS.sub(currentCliff);
+        var mintedAmount = crvAmount.mul(remainingCliffs).div(CVX_TOTAL_CLIFFS);
+        var amountTillMax = CVX_MAX_SUPPLY.sub(cvxSupply);
+        return mintedAmount.gt(amountTillMax) ? amountTillMax : mintedAmount;
+    }
+    return ethers_1.BigNumber.from(0);
+}
+function getPoolData(basePoolAddress, underlying, cvxAddress, extraPoolAddresses, provider) {
+    return __awaiter(this, void 0, void 0, function () {
+        var calls;
+        return __generator(this, function (_a) {
+            calls = __spreadArray([
+                {
+                    address: basePoolAddress,
+                    interface: types_1.IBaseRewardPool__factory.createInterface(),
+                    method: "rewardRate()"
+                },
+                {
+                    address: basePoolAddress,
+                    interface: types_1.IBaseRewardPool__factory.createInterface(),
+                    method: "totalSupply()"
+                },
+                {
+                    address: underlying,
+                    interface: types_1.CurveV1AdapterStETH__factory.createInterface(),
+                    method: "get_virtual_price()"
+                },
+                {
+                    address: cvxAddress,
+                    interface: types_1.IConvexToken__factory.createInterface(),
+                    method: "totalSupply()"
+                }
+            ], extraPoolAddresses.map(function (extraPoolAddress) { return ({
+                address: extraPoolAddress,
+                interface: types_1.IBaseRewardPool__factory.createInterface(),
+                method: "rewardRate()"
+            }); }), true);
+            return [2 /*return*/, (0, multicall_1.multicall)(calls, provider)];
+        });
+    });
+}
+var curveLPTokenToPoolName = {
+    "3Crv": "3pool",
+    FRAX3CRV: "frax",
+    gusd3CRV: "gusd",
+    LUSD3CRV: "lusd",
+    crvPlain3andSUSD: "susdv2",
+    steCRV: "steth"
+};
+var RESPONSE_DECIMALS = 100;
+// https://www.convexfinance.com/api/curve-apys
+function getCurveBaseApy(curveLPToken) {
+    return __awaiter(this, void 0, void 0, function () {
+        var poolName, url, result, _a, baseApy, e_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    poolName = curveLPTokenToPoolName[curveLPToken];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    url = "https://www.convexfinance.com/api/curve-apys";
+                    return [4 /*yield*/, axios_1.default.get(url)];
+                case 2:
+                    result = _b.sent();
+                    _a = (result.data.apys[poolName] || {}).baseApy, baseApy = _a === void 0 ? 0 : _a;
+                    return [2 /*return*/, (0, formatter_1.toBN)((baseApy / RESPONSE_DECIMALS).toString(), constants_1.WAD_DECIMALS_POW)];
+                case 3:
+                    e_1 = _b.sent();
+                    return [2 /*return*/, ethers_1.BigNumber.from(0)];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.getCurveBaseApy = getCurveBaseApy;

package/lib/apy/lidoAPY.d.ts

@@ -0,0 +1,4 @@
+import { providers } from "ethers";
+import { NetworkType } from "../core/constants";
+export declare function getLidoApy(provider: providers.Provider, networkType: NetworkType): Promise<readonly [import("ethers").BigNumber, number]>;
+export declare const LIDO_FEE_DECIMALS = 10000;

package/lib/apy/lidoAPY.js

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIDO_FEE_DECIMALS = exports.getLidoApy = void 0;
+var multicall_1 = require("../utils/multicall");
+var contracts_1 = require("../contracts/contracts");
+var token_1 = require("../tokens/token");
+var constants_1 = require("../core/constants");
+var types_1 = require("../types");
+var lidoOracles = contracts_1.contractParams.LIDO_STETH_GATEWAY.oracle;
+var lidoStEth = {
+    Mainnet: token_1.tokenDataByNetwork.Mainnet.STETH,
+    Kovan: token_1.tokenDataByNetwork.Kovan.STETH
+};
+function getLidoApy(provider, networkType) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b, postTotalPooledEther, preTotalPooledEther, timeElapsed, fee, lidoAPRRay;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (!lidoOracles[networkType]) {
+                        throw new Error("No Lido APR oracle found on current network: ".concat(networkType));
+                    }
+                    if (!lidoStEth[networkType]) {
+                        throw new Error("No Lido stETH found on current network: ".concat(networkType));
+                    }
+                    return [4 /*yield*/, geLidoData(lidoOracles[networkType], lidoStEth[networkType], provider, networkType)];
+                case 1:
+                    _a = _c.sent(), _b = _a[0], postTotalPooledEther = _b.postTotalPooledEther, preTotalPooledEther = _b.preTotalPooledEther, timeElapsed = _b.timeElapsed, fee = _a[1];
+                    lidoAPRRay = postTotalPooledEther
+                        .sub(preTotalPooledEther)
+                        .mul(constants_1.SECONDS_PER_YEAR)
+                        .mul(constants_1.WAD)
+                        .div(preTotalPooledEther.mul(timeElapsed));
+                    return [2 /*return*/, [lidoAPRRay, fee]];
+            }
+        });
+    });
+}
+exports.getLidoApy = getLidoApy;
+exports.LIDO_FEE_DECIMALS = 10000;
+function geLidoData(lidoOracleAddress, stETHAddress, provider, network) {
+    return __awaiter(this, void 0, void 0, function () {
+        var calls, _a, stats, _b, fee;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    calls = [
+                        {
+                            address: lidoOracleAddress,
+                            interface: types_1.ILidoOracle__factory.createInterface(),
+                            method: "getLastCompletedReportDelta()"
+                        }
+                    ];
+                    if (network !== "Kovan")
+                        calls.push({
+                            address: stETHAddress,
+                            interface: types_1.IstETH__factory.createInterface(),
+                            method: "getFee()"
+                        });
+                    return [4 /*yield*/, (0, multicall_1.multicall)(calls, provider)];
+                case 1:
+                    _a = _c.sent(), stats = _a[0], _b = _a[1], fee = _b === void 0 ? Math.floor(exports.LIDO_FEE_DECIMALS / 10) : _b;
+                    return [2 /*return*/, [stats, fee]];
+            }
+        });
+    });
+}

package/lib/config.d.ts

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

package/lib/config.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STATIC_TOKEN = void 0;
+exports.MULTICALL_ADDRESS = exports.STATIC_TOKEN = void 0;
 exports.STATIC_TOKEN = "https://static.gearbox.fi/tokens/";
+exports.MULTICALL_ADDRESS = "0x5ba1e12693dc8f9c48aad8770482f4739beed696";

package/lib/contracts/contracts.d.ts

@@ -1,9 +1,9 @@
 import { AdapterInterface } from "./adapters";
 import { NetworkType } from "../core/constants";
 import { Protocols } from "./protocols";
-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 declare type UniswapV2Contract = "UNISWAP_V2_ROUTER" | "SUSHISWAP_ROUTER";
 export declare type CurvePoolContract = "CURVE_3CRV_POOL" | "CURVE_STETH_GATEWAY" | "CURVE_FRAX_POOL" | "CURVE_LUSD_POOL" | "CURVE_GUSD_POOL" | "CURVE_SUSD_POOL" | "CURVE_SUSD_DEPOSIT";
 export declare type YearnVaultContract = "YEARN_DAI_VAULT" | "YEARN_USDC_VAULT" | "YEARN_WETH_VAULT" | "YEARN_WBTC_VAULT" | "YEARN_CURVE_FRAX_VAULT" | "YEARN_CURVE_STETH_VAULT";
@@ -44,10 +44,15 @@ declare type ConvexParams = {
     protocol: Protocols.Convex;
     type: AdapterInterface.CONVEX_V1_BOOSTER | AdapterInterface.CONVEX_V1_CLAIM_ZAP;
 } & BaseContractParams;
-declare type ConvexPoolParams = {
+declare type ConvexExtraPoolParams = {
+    rewardToken: NormalToken;
+    poolAddress: Record<NetworkType, string>;
+};
+export declare type ConvexPoolParams = {
     protocol: Protocols.Convex;
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL;
     stakedToken: ConvexStakedPhantomToken;
+    extraRewards: Array<ConvexExtraPoolParams>;
 } & BaseContractParams;
 export declare type LidoParams = {
     protocol: Protocols.Lido;

package/lib/contracts/contracts.js

@@ -197,46 +197,84 @@ exports.contractParams = {
         protocol: protocols_1.Protocols.Convex,
         type: adapters_1.AdapterInterface.CONVEX_V1_BOOSTER
     },
+    CONVEX_CLAIM_ZAP: {
+        name: "Convex ZAP",
+        protocol: protocols_1.Protocols.Convex,
+        type: adapters_1.AdapterInterface.CONVEX_V1_CLAIM_ZAP
+    },
     CONVEX_3CRV_POOL: {
         name: "Convex 3crv",
         protocol: protocols_1.Protocols.Convex,
         type: adapters_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-        stakedToken: "stkcvx3Crv"
+        stakedToken: "stkcvx3Crv",
+        extraRewards: []
     },
     CONVEX_GUSD_POOL: {
         name: "Convex GUSD",
         protocol: protocols_1.Protocols.Convex,
         type: adapters_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-        stakedToken: "stkcvxgusd3CRV"
+        stakedToken: "stkcvxgusd3CRV",
+        extraRewards: []
     },
     CONVEX_SUSD_POOL: {
         name: "Convex SUSD",
         protocol: protocols_1.Protocols.Convex,
         type: adapters_1.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_1.Protocols.Convex,
         type: adapters_1.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_1.Protocols.Convex,
         type: adapters_1.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_1.Protocols.Convex,
         type: adapters_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-        stakedToken: "stkcvxLUSD3CRV"
-    },
-    CONVEX_CLAIM_ZAP: {
-        name: "Convex ZAP",
-        protocol: protocols_1.Protocols.Convex,
-        type: adapters_1.AdapterInterface.CONVEX_V1_CLAIM_ZAP
+        stakedToken: "stkcvxLUSD3CRV",
+        extraRewards: [
+            {
+                rewardToken: "LQTY",
+                poolAddress: {
+                    Mainnet: "0x55d59b791f06dc519B176791c4E037E8Cf2f6361",
+                    Kovan: ""
+                }
+            }
+        ]
     },
     LIDO_STETH_GATEWAY: {
         name: "Lido STETH",
@@ -249,7 +287,7 @@ exports.contractParams = {
         lpToken: "steCRV"
     }
 };
-exports.contractsByAddress = (0, mappers_1.objectEntries)(exports.contractsByNetwork).reduce(function (sum, _a) {
-    var _ = _a[0], contracts = _a[1];
-    return __assign(__assign({}, sum), (0, mappers_1.keyToLowercase)((0, mappers_1.swapKeyValue)(contracts)));
+exports.contractsByAddress = (0, mappers_1.objectEntries)(exports.contractsByNetwork).reduce(function (acc, _a) {
+    var contracts = _a[1];
+    return (__assign(__assign({}, acc), (0, mappers_1.filterEmptyKeys)((0, mappers_1.keyToLowercase)((0, mappers_1.swapKeyValue)(contracts)))));
 }, {});

package/lib/contracts/contractsRegister.js

@@ -38,18 +38,30 @@ exports.deployedContracts = {
     "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"
 };
-var contractNames = Object.entries(contracts_1.contractsByAddress).reduce(function (sum, _a) {
+var contractNames = Object.entries(contracts_1.contractsByAddress).reduce(function (acc, _a) {
     var _b;
     var addr = _a[0], cSymbol = _a[1];
     var params = contracts_1.contractParams[cSymbol];
     if (!params)
-        return sum;
-    return __assign(__assign({}, sum), (_b = {}, _b[addr] = params.name, _b));
+        return acc;
+    return __assign(__assign({}, acc), (_b = {}, _b[addr] = params.name, _b));
 }, {});
 var contractsFullList = __assign(__assign({}, (0, mappers_1.keyToLowercase)(exports.deployedContracts)), contractNames);
 function getContractName(address) {

package/lib/core/constants.d.ts

@@ -5,13 +5,19 @@ export declare const KOVAN_NETWORK = 42;
 export declare const LOCAL_NETWORK = 1337;
 export declare type NetworkType = "Mainnet" | "Kovan";
 export declare const getNetworkType: (chainId: number) => NetworkType;
+export declare const RAY_DECIMALS_POW = 27;
 export declare const RAY: BigNumber;
 export declare const halfRAY: BigNumber;
+export declare const WAD_DECIMALS_POW = 18;
 export declare const WAD: BigNumber;
+export declare const PRICE_DECIMALS_POW = 8;
+export declare const PRICE_DECIMALS: BigNumber;
 export declare const SECONDS_PER_YEAR: number;
+export declare const PERCENTAGE_DECIMALS = 100;
 export declare const PERCENTAGE_FACTOR = 10000;
 export declare const LIQUIDATION_DISCOUNTED_SUM = 9500;
 export declare const UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD = 9300;
 export declare const timeRanges: Record<string, number>;
 export declare const LEVERAGE_DECIMALS = 100;
-export declare const ADDRESS_0x0 = "0x0000000000000000000000000000000000000000";
+export declare const SLIPPAGE_DECIMALS = 100;
+export declare const ADDRESS_0X0 = "0x0000000000000000000000000000000000000000";

package/lib/core/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ADDRESS_0x0 = exports.LEVERAGE_DECIMALS = exports.timeRanges = exports.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD = exports.LIQUIDATION_DISCOUNTED_SUM = exports.PERCENTAGE_FACTOR = exports.SECONDS_PER_YEAR = exports.WAD = exports.halfRAY = exports.RAY = exports.getNetworkType = exports.LOCAL_NETWORK = exports.KOVAN_NETWORK = exports.MAINNET_NETWORK = exports.MAX_INT = void 0;
+exports.ADDRESS_0X0 = exports.SLIPPAGE_DECIMALS = exports.LEVERAGE_DECIMALS = exports.timeRanges = exports.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD = exports.LIQUIDATION_DISCOUNTED_SUM = exports.PERCENTAGE_FACTOR = exports.PERCENTAGE_DECIMALS = exports.SECONDS_PER_YEAR = exports.PRICE_DECIMALS = exports.PRICE_DECIMALS_POW = exports.WAD = exports.WAD_DECIMALS_POW = exports.halfRAY = exports.RAY = exports.RAY_DECIMALS_POW = exports.getNetworkType = exports.LOCAL_NETWORK = exports.KOVAN_NETWORK = exports.MAINNET_NETWORK = exports.MAX_INT = void 0;
 var ethers_1 = require("ethers");
 exports.MAX_INT = ethers_1.BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 exports.MAINNET_NETWORK = 1;
@@ -18,10 +18,15 @@ var getNetworkType = function (chainId) {
     }
 };
 exports.getNetworkType = getNetworkType;
-exports.RAY = ethers_1.BigNumber.from(10).pow(27);
+exports.RAY_DECIMALS_POW = 27;
+exports.RAY = ethers_1.BigNumber.from(10).pow(exports.RAY_DECIMALS_POW);
 exports.halfRAY = exports.RAY.div(2);
-exports.WAD = ethers_1.BigNumber.from(10).pow(18);
+exports.WAD_DECIMALS_POW = 18;
+exports.WAD = ethers_1.BigNumber.from(10).pow(exports.WAD_DECIMALS_POW);
+exports.PRICE_DECIMALS_POW = 8;
+exports.PRICE_DECIMALS = ethers_1.BigNumber.from(10).pow(exports.PRICE_DECIMALS_POW);
 exports.SECONDS_PER_YEAR = 365 * 24 * 3600;
+exports.PERCENTAGE_DECIMALS = 100;
 exports.PERCENTAGE_FACTOR = 1e4;
 exports.LIQUIDATION_DISCOUNTED_SUM = 9500;
 exports.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD = 9300;
@@ -30,7 +35,8 @@ exports.timeRanges = {
     "1D": 3600 * 24,
     "1W": 3600 * 24 * 7,
     "1M": 3600 * 24 * 30,
-    "1Y": 3600 * 24 * 365,
+    "1Y": 3600 * 24 * 365
 };
 exports.LEVERAGE_DECIMALS = 100;
-exports.ADDRESS_0x0 = "0x0000000000000000000000000000000000000000";
+exports.SLIPPAGE_DECIMALS = 100;
+exports.ADDRESS_0X0 = "0x0000000000000000000000000000000000000000";

package/lib/core/creditAccount.d.ts

@@ -23,8 +23,10 @@ export declare class CreditAccountData {
     isDeleting: boolean;
     readonly version: number;
     constructor(payload: CreditAccountDataPayload);
-    balancesSorted(prices: Record<string, number>, tokens: Record<string, TokenData>): Array<Balance>;
+    balancesSorted(prices: Record<string, BigNumber>, tokens: Record<string, TokenData>): Array<Balance>;
 }
+export declare function sortBalances(balances: Record<string, BigNumber>, prices: Record<string, BigNumber>, tokens: Record<string, TokenData>): [string, BigNumber][];
+export declare function tokensAbcComparator(t1?: TokenData, t2?: TokenData): 1 | -1;
 export declare class CreditAccountDataExtended extends CreditAccountData {
     readonly repayAmount: BigNumber;
     readonly liquidationAmount: BigNumber;