impermax-sdk 1.0.3 → 1.0.5

package/lib/impermax-router/AccountCollateral.js

@@ -0,0 +1,63 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const AccountPoolToken_1 = __importDefault(require("./AccountPoolToken"));
+class AccountCollateral extends AccountPoolToken_1.default {
+    constructor() {
+        super(...arguments);
+        this.collateralCache = {};
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.collateralCache = {};
+    }
+    fixStakedLPExchangeRate(n) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stakedLPExchangeRate = yield this.poolToken.lendingPool.getStakedLPExchangeRate();
+            return (yield n) / stakedLPExchangeRate;
+        });
+    }
+    getAvailableBalanceUSD() {
+        const _super = Object.create(null, {
+            getAvailableBalanceUSD: { get: () => super.getAvailableBalanceUSD }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fixStakedLPExchangeRate(_super.getAvailableBalanceUSD.call(this));
+        });
+    }
+    getDepositedUSD() {
+        const _super = Object.create(null, {
+            getDepositedUSD: { get: () => super.getDepositedUSD }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fixStakedLPExchangeRate(_super.getDepositedUSD.call(this));
+        });
+    }
+    // Max Withdrawable
+    getMaxWithdrawable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deposited = yield this.getDeposited();
+            const availableCash = yield this.poolToken.getTotalBalance();
+            const { valueCollateral, valueA, valueB } = yield this.accountLendingPool.getValues(types_1.NO_CHANGES);
+            const safetyMargin = (yield this.accountLendingPool.getSafetyMargin()) * this.getUiMargin();
+            const liquidationPenalty = yield this.accountLendingPool.getLiquidationPenalty();
+            const actualCollateral = valueCollateral / liquidationPenalty;
+            const maxWithdrawable1 = (actualCollateral - (valueA + valueB * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty;
+            const maxWithdrawable2 = (actualCollateral - (valueB + valueA * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty;
+            return Math.max(0, Math.min(deposited, availableCash, maxWithdrawable1, maxWithdrawable2) / this.getDust());
+        });
+    }
+}
+exports.default = AccountCollateral;

package/lib/impermax-router/AccountLendingPool.d.ts

@@ -0,0 +1,57 @@
+import { Changes, PendingRewardUI, Values } from "./types";
+import Account from "./Account";
+import AccountBorrowable from "./AccountBorrowable";
+import AccountCollateral from "./AccountCollateral";
+import LendingPool from "./LendingPool";
+import { PoolTokenType } from '../config/types';
+export default class AccountLendingPool {
+    account: Account;
+    lendingPool: LendingPool;
+    accountPoolTokens: {
+        [PoolTokenType.Collateral]: AccountCollateral;
+        [PoolTokenType.BorrowableA]: AccountBorrowable;
+        [PoolTokenType.BorrowableB]: AccountBorrowable;
+    };
+    cache: {
+        availableReward?: Promise<PendingRewardUI[]>;
+        oldAvailableReward?: Promise<number>;
+    };
+    constructor(account: Account, lendingPool: LendingPool);
+    cleanCache(): void;
+    pta: () => AccountBorrowable;
+    ptb: () => AccountBorrowable;
+    ptc: () => AccountCollateral;
+    getSafetyMargin: () => Promise<number>;
+    getLiquidationPenalty: () => Promise<number>;
+    getUiMargin: () => number;
+    getBalanceUSD(): Promise<number>;
+    getSuppliedUSD(): Promise<number>;
+    getDebtUSD(): Promise<number>;
+    getEquityUSD(): Promise<number>;
+    getLPEquityUSD(): Promise<number>;
+    getLPEquity(): Promise<number>;
+    getAccountAPR(): Promise<number>;
+    getValuesFromPrice(changes: Changes, priceA: number, priceB: number): Promise<{
+        valueCollateral: number;
+        valueA: number;
+        valueB: number;
+    }>;
+    getValues(changes: Changes): Promise<{
+        valueCollateral: number;
+        valueA: number;
+        valueB: number;
+    }>;
+    getMarketValues(changes: Changes): Promise<{
+        valueCollateral: number;
+        valueA: number;
+        valueB: number;
+    }>;
+    getLeverage(changes?: Changes): Promise<number>;
+    getLiquidationPriceSwingsGivenValues(values: Values): Promise<[number, number]>;
+    getLiquidationPricesGivenValues(values: Values): Promise<[number, number]>;
+    getLiquidationPriceSwings(changes?: Changes): Promise<[number, number]>;
+    getLiquidationPrices(changes?: Changes): Promise<[number, number]>;
+    getMaxLeverage(): Promise<number>;
+    getMaxDeleverage(slippage: number): Promise<number>;
+    getAvailableReward(): Promise<PendingRewardUI[]>;
+}

package/lib/impermax-router/AccountLendingPool.js

@@ -0,0 +1,266 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const AccountBorrowable_1 = __importDefault(require("./AccountBorrowable"));
+const AccountCollateral_1 = __importDefault(require("./AccountCollateral"));
+const types_2 = require("../config/types");
+class AccountLendingPool {
+    constructor(account, lendingPool) {
+        this.cache = {};
+        // Shortcuts
+        this.pta = () => this.accountPoolTokens[types_2.PoolTokenType.BorrowableA];
+        this.ptb = () => this.accountPoolTokens[types_2.PoolTokenType.BorrowableB];
+        this.ptc = () => this.accountPoolTokens[types_2.PoolTokenType.Collateral];
+        this.getSafetyMargin = () => __awaiter(this, void 0, void 0, function* () { return (yield this.lendingPool.getSubgraphLendingPool()).getSafetyMargin(); });
+        this.getLiquidationPenalty = () => __awaiter(this, void 0, void 0, function* () { return (yield this.lendingPool.getSubgraphLendingPool()).getLiquidationPenalty(); });
+        this.getUiMargin = () => this.account.router.uiMargin;
+        this.account = account;
+        this.lendingPool = lendingPool;
+        this.accountPoolTokens = {
+            [types_2.PoolTokenType.Collateral]: new AccountCollateral_1.default(this, types_2.PoolTokenType.Collateral),
+            [types_2.PoolTokenType.BorrowableA]: new AccountBorrowable_1.default(this, types_2.PoolTokenType.BorrowableA),
+            [types_2.PoolTokenType.BorrowableB]: new AccountBorrowable_1.default(this, types_2.PoolTokenType.BorrowableB),
+        };
+    }
+    cleanCache() {
+        this.cache = {};
+        this.pta().cleanCache();
+        this.ptb().cleanCache();
+        this.ptc().cleanCache();
+    }
+    // Balance
+    getBalanceUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const depositedAUSD = yield this.pta().getDepositedUSD();
+            const depositedBUSD = yield this.ptb().getDepositedUSD();
+            const depositedCUSD = yield this.ptc().getDepositedUSD();
+            return depositedAUSD + depositedBUSD + depositedCUSD;
+        });
+    }
+    // Supplied
+    getSuppliedUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const depositedAUSD = yield this.pta().getDepositedUSD();
+            const depositedBUSD = yield this.ptb().getDepositedUSD();
+            return depositedAUSD + depositedBUSD;
+        });
+    }
+    // Debt
+    getDebtUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowedAUSD = yield this.pta().getBorrowedUSD();
+            const borrowedBUSD = yield this.ptb().getBorrowedUSD();
+            return borrowedAUSD + borrowedBUSD;
+        });
+    }
+    // Equity
+    getEquityUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const balanceUSD = yield this.getBalanceUSD();
+            const debtUSD = yield this.getDebtUSD();
+            return balanceUSD - debtUSD;
+        });
+    }
+    getLPEquityUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collateralUSD = yield this.ptc().getDepositedUSD();
+            const debtUSD = yield this.getDebtUSD();
+            return collateralUSD - debtUSD;
+        });
+    }
+    getLPEquity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lpEquityUSD = yield this.getLPEquityUSD();
+            const tokenPrice = yield this.ptc().getTokenPriceAccurate();
+            const stakedLPExchangeRate = yield this.lendingPool.getStakedLPExchangeRate();
+            return lpEquityUSD / tokenPrice * stakedLPExchangeRate;
+        });
+    }
+    // Debt
+    getAccountAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const depositedAUSD = yield this.pta().getDepositedUSD();
+            const depositedBUSD = yield this.ptb().getDepositedUSD();
+            const totalSupplied = depositedAUSD + depositedBUSD;
+            const supplyAPRA = yield this.pta().getSupplyAPR();
+            const supplyAPRB = yield this.ptb().getSupplyAPR();
+            return totalSupplied > 0 ? (depositedAUSD * supplyAPRA + depositedBUSD * supplyAPRB) / totalSupplied : 0;
+        });
+    }
+    // Values
+    getValuesFromPrice(changes, priceA, priceB) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const valueCollateral = (yield this.ptc().getDeposited()) + changes.changeCollateral;
+            const amountA = (yield this.pta().getBorrowed()) + changes.changeBorrowedA;
+            const amountB = (yield this.ptb().getBorrowed()) + changes.changeBorrowedB;
+            const valueA = amountA * priceA;
+            const valueB = amountB * priceB;
+            return {
+                valueCollateral: valueCollateral > 0 ? valueCollateral : 0,
+                valueA: valueA > 0 ? valueA : 0,
+                valueB: valueB > 0 ? valueB : 0,
+            };
+        });
+    }
+    getValues(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [priceA, priceB] = yield this.lendingPool.getPriceDenomLP();
+            return this.getValuesFromPrice(changes, priceA, priceB);
+        });
+    }
+    getMarketValues(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [priceA, priceB] = yield this.lendingPool.getMarketPriceDenomLP();
+            return this.getValuesFromPrice(changes, priceA, priceB);
+        });
+    }
+    // Leverage
+    getLeverage(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!changes)
+                changes = types_1.NO_CHANGES;
+            const { valueCollateral, valueA, valueB } = yield this.getValues(changes);
+            const valueDebt = valueA + valueB;
+            if (valueDebt == 0)
+                return 1;
+            const equity = valueCollateral - valueDebt;
+            if (equity <= 0)
+                return Infinity;
+            return valueDebt / equity + 1;
+        });
+    }
+    // Liquidation Threshold
+    getLiquidationPriceSwingsGivenValues(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!values)
+                return [Infinity, Infinity];
+            const { valueCollateral, valueA, valueB } = values;
+            if (valueA + valueB == 0)
+                return [Infinity, Infinity];
+            const safetyMargin = yield this.getSafetyMargin();
+            const liquidationPenalty = yield this.getLiquidationPenalty();
+            const actualCollateral = valueCollateral / liquidationPenalty;
+            const rad = Math.sqrt(Math.pow(actualCollateral, 2) - 4 * valueA * valueB);
+            if (!rad)
+                return [0, 0];
+            const t = (actualCollateral + rad) / (2 * Math.sqrt(safetyMargin));
+            let priceSwingA = Math.pow((t / valueA), 2);
+            let priceSwingB = Math.pow((t / valueB), 2);
+            return [priceSwingA, priceSwingB];
+        });
+    }
+    getLiquidationPricesGivenValues(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentPrice = yield this.lendingPool.getTWAPPrice();
+            const [priceSwingA, priceSwingB] = yield this.getLiquidationPriceSwingsGivenValues(values);
+            return !this.account.router.priceInverted ? [currentPrice / priceSwingB, currentPrice * priceSwingA] : [currentPrice / priceSwingA, currentPrice * priceSwingB];
+        });
+    }
+    getLiquidationPriceSwings(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const values = yield this.getValues(changes);
+            return this.getLiquidationPriceSwingsGivenValues(values);
+        });
+    }
+    getLiquidationPrices(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!changes)
+                changes = types_1.NO_CHANGES;
+            const values = yield this.getValues(changes);
+            return this.getLiquidationPricesGivenValues(values);
+        });
+    }
+    // Max Leverage
+    getMaxLeverage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableCashA = yield this.pta().poolToken.getTotalBalance();
+            const availableCashB = yield this.ptb().poolToken.getTotalBalance();
+            const [priceA, priceB] = yield this.lendingPool.getMarketPriceDenomLP();
+            const [priceATWAP,] = yield this.lendingPool.getPriceDenomLP();
+            const diff = priceA > priceATWAP ? priceA / priceATWAP : priceATWAP / priceA;
+            const adjustFactor = 1 / diff;
+            const availableCashValue1 = availableCashA * priceA;
+            const availableCashValue2 = availableCashB * priceB;
+            const { valueCollateral, valueA, valueB } = yield this.getValues(types_1.NO_CHANGES);
+            const safetyMargin = (yield this.getSafetyMargin()) * this.getUiMargin();
+            const liquidationPenalty = yield this.getLiquidationPenalty();
+            const actualCollateral = valueCollateral / liquidationPenalty;
+            const num1 = actualCollateral * Math.sqrt(safetyMargin) - valueA * safetyMargin - valueB;
+            const num2 = actualCollateral * Math.sqrt(safetyMargin) - valueB * safetyMargin - valueA;
+            const den = safetyMargin + 1 - 2 * Math.sqrt(safetyMargin) / liquidationPenalty;
+            const additionalValueBorrowablePerSide = Math.min(num1 / den, num2 / den, availableCashValue1, availableCashValue2) * adjustFactor;
+            const valueDebt = valueA + valueB;
+            const equity = valueCollateral - valueDebt;
+            if (equity == 0)
+                return 1;
+            return (valueDebt + additionalValueBorrowablePerSide * 2) / equity + 1;
+        });
+    }
+    // Max Deleverage
+    getMaxDeleverage(slippage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { valueCollateral, valueA, valueB } = yield this.getMarketValues(types_1.NO_CHANGES);
+            const minRepayPerSide = valueCollateral / 2 / Math.sqrt(slippage);
+            if (minRepayPerSide >= valueA && minRepayPerSide >= valueB) {
+                return this.ptc().getDeposited();
+            }
+            if (minRepayPerSide * 2 < valueA + valueB) {
+                return 0;
+            }
+            return Math.min(valueA, valueB) * 2 * Math.sqrt(slippage);
+        });
+    }
+    // Available Reward
+    getAvailableReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = [];
+            const imxAmount = (yield this.pta().getAvailableIMXReward()) + (yield this.ptb().getAvailableIMXReward());
+            if (imxAmount > 0)
+                result.push({
+                    symbol: "IMX",
+                    amount: imxAmount
+                });
+            const symbols = [
+                yield this.pta().poolToken.getRewarderTokenSymbol(),
+                yield this.ptb().poolToken.getRewarderTokenSymbol()
+            ];
+            const rewarderAmounts = [
+                yield this.pta().getAvailableRewarderReward(),
+                yield this.ptb().getAvailableRewarderReward()
+            ];
+            if (symbols[0] === symbols[1]) {
+                const rewarderAmount = rewarderAmounts[0] + rewarderAmounts[1];
+                if (rewarderAmount === 0)
+                    return result;
+                result.push({
+                    symbol: symbols[0],
+                    amount: rewarderAmount
+                });
+            }
+            else {
+                for (let i = 0; i < 2; i++) {
+                    if (rewarderAmounts[i] === 0)
+                        continue;
+                    result.push({
+                        symbol: symbols[i],
+                        amount: rewarderAmounts[i]
+                    });
+                }
+            }
+            return result;
+        });
+    }
+}
+exports.default = AccountLendingPool;

package/lib/impermax-router/AccountPoolToken.d.ts

@@ -0,0 +1,29 @@
+import AccountLendingPool from "./AccountLendingPool";
+import PoolToken from "./PoolToken";
+import { PoolTokenType } from '../config/types';
+export default class AccountPoolToken {
+    accountLendingPool: AccountLendingPool;
+    poolToken: PoolToken;
+    cache: {
+        availableBalance?: Promise<number>;
+        deposited?: Promise<number>;
+    };
+    constructor(accountLendingPool: AccountLendingPool, poolTokenType: PoolTokenType);
+    cleanCache(): void;
+    getAccount: () => string;
+    getNetwrok: () => import("../config/types").Networks;
+    getEth: () => any;
+    getDust: () => number;
+    getUiMargin: () => number;
+    getTokenPriceAccurate: () => Promise<number>;
+    getSupplyAPR: () => Promise<number>;
+    getBorrowRate: () => Promise<number>;
+    getAccrualTimestamp: () => Promise<number>;
+    private initializeAvailableBalance;
+    getAvailableBalance(): Promise<number>;
+    getAvailableBalanceUSD(): Promise<number>;
+    private initializeDeposited;
+    getDeposited(): Promise<number>;
+    getDepositedUSD(): Promise<number>;
+    getMaxWithdrawable(): Promise<number>;
+}

package/lib/impermax-router/AccountPoolToken.js

@@ -0,0 +1,89 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const weths_1 = require("../config/contracts/weths");
+class AccountPoolToken {
+    constructor(accountLendingPool, poolTokenType) {
+        this.cache = {};
+        // Shortcuts
+        this.getAccount = () => this.accountLendingPool.account.account;
+        this.getNetwrok = () => this.accountLendingPool.account.router.network;
+        this.getEth = () => this.accountLendingPool.account.router.web3.eth;
+        this.getDust = () => this.accountLendingPool.account.router.dust;
+        this.getUiMargin = () => this.accountLendingPool.account.router.uiMargin;
+        this.getTokenPriceAccurate = () => __awaiter(this, void 0, void 0, function* () { return (yield this.poolToken.getSubgraphPoolToken()).getTokenPriceAccurate(); });
+        this.getSupplyAPR = () => __awaiter(this, void 0, void 0, function* () { return (yield this.poolToken.getSubgraphPoolToken()).getSupplyAPR(); });
+        this.getBorrowRate = () => __awaiter(this, void 0, void 0, function* () { return (yield this.poolToken.getSubgraphPoolToken()).getBorrowRate(); });
+        this.getAccrualTimestamp = () => __awaiter(this, void 0, void 0, function* () { return (yield this.poolToken.getSubgraphPoolToken()).getAccrualTimestamp(); });
+        this.accountLendingPool = accountLendingPool;
+        this.poolToken = accountLendingPool.lendingPool.poolTokens[poolTokenType];
+    }
+    cleanCache() {
+        this.cache = {};
+    }
+    // Available Balance
+    initializeAvailableBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.poolToken.getToken();
+            if (token._address.toLowerCase() == weths_1.WETH[this.getNetwrok()].toLowerCase()) {
+                return (yield this.getEth().getBalance(this.getAccount())) / 1e18 / this.getDust();
+            }
+            const balance = yield token.methods.balanceOf(this.getAccount()).call();
+            return (yield this.poolToken.normalize(balance)) / this.getDust();
+        });
+    }
+    getAvailableBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.availableBalance)
+                this.cache.availableBalance = this.initializeAvailableBalance();
+            return this.cache.availableBalance;
+        });
+    }
+    getAvailableBalanceUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableBalance = yield this.getAvailableBalance();
+            const tokenPrice = yield this.getTokenPriceAccurate();
+            return availableBalance * tokenPrice;
+        });
+    }
+    // Deposited
+    initializeDeposited() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolToken = yield this.poolToken.getPoolToken();
+            const exchangeRate = yield this.poolToken.getExchangeRate();
+            const balance = yield poolToken.methods.balanceOf(this.getAccount()).call();
+            return (yield this.poolToken.normalize(balance)) * exchangeRate;
+        });
+    }
+    getDeposited() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.deposited)
+                this.cache.deposited = this.initializeDeposited();
+            return this.cache.deposited;
+        });
+    }
+    getDepositedUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deposited = yield this.getDeposited();
+            const tokenPrice = yield this.getTokenPriceAccurate();
+            return deposited * tokenPrice;
+        });
+    }
+    // Max Withdrawable
+    getMaxWithdrawable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deposited = yield this.getDeposited();
+            const availableCash = yield this.poolToken.getTotalBalance();
+            return Math.min(deposited, availableCash) / this.getDust();
+        });
+    }
+}
+exports.default = AccountPoolToken;

package/lib/impermax-router/Borrowable.d.ts

@@ -0,0 +1,27 @@
+import { Contract } from "./types";
+import PoolToken from "./PoolToken";
+import { Address } from '../config/types';
+export default class Borrowable extends PoolToken {
+    borrowableCache: {
+        borrowTracker?: Promise<Address>;
+        rewarder?: Promise<Contract>;
+        rewarderTokenSymbol?: Promise<string>;
+        rewardSpeed?: Promise<number>;
+    };
+    cleanCache(): void;
+    initializePoolToken(): Promise<Contract>;
+    initializeToken(): Promise<Contract>;
+    getPriceDenomLP(): Promise<number>;
+    getMarketPriceDenomLP(): Promise<number>;
+    private initializeBorrowTracker;
+    getBorrowTracker(): Promise<string>;
+    hasFarming(): Promise<boolean>;
+    hasImpermaxChef(): Promise<boolean>;
+    getFarmingPool(): Promise<Contract>;
+    getImpermaxChef: () => any;
+    private initializeRewarder;
+    getRewarder(): Promise<any>;
+    hasRewarder(): Promise<boolean>;
+    private initializeRewarderTokenSymbol;
+    getRewarderTokenSymbol(): Promise<string>;
+}

package/lib/impermax-router/Borrowable.js

@@ -0,0 +1,128 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PoolToken_1 = __importDefault(require("./PoolToken"));
+const types_1 = require("../config/types");
+class Borrowable extends PoolToken_1.default {
+    constructor() {
+        super(...arguments);
+        this.borrowableCache = {};
+        this.getImpermaxChef = () => this.getContractHelper().impermaxChef;
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.borrowableCache = {};
+    }
+    initializePoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getContractHelper().newBorrowable(yield this.getPoolTokenAddressFromLendingPool());
+        });
+    }
+    initializeToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolToken = yield this.getPoolToken();
+            return this.getContractHelper().newERC20(yield poolToken.methods.underlying().call());
+        });
+    }
+    // Price Denom LP
+    getPriceDenomLP() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prices = yield this.lendingPool.getPriceDenomLP();
+            return prices[this.poolTokenType === types_1.PoolTokenType.BorrowableA ? 0 : 1];
+        });
+    }
+    getMarketPriceDenomLP() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prices = yield this.lendingPool.getMarketPriceDenomLP();
+            return prices[this.poolTokenType === types_1.PoolTokenType.BorrowableA ? 0 : 1];
+        });
+    }
+    // Farming Pool
+    initializeBorrowTracker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowable = yield this.getPoolToken();
+            return borrowable.methods.borrowTracker().call();
+        });
+    }
+    getBorrowTracker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.borrowTracker)
+                this.borrowableCache.borrowTracker = this.initializeBorrowTracker();
+            return this.borrowableCache.borrowTracker;
+        });
+    }
+    hasFarming() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowTracker = yield this.getBorrowTracker();
+            return borrowTracker !== '0x0000000000000000000000000000000000000000';
+        });
+    }
+    hasImpermaxChef() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowTracker = yield this.getBorrowTracker();
+            return borrowTracker.toLowerCase() === ((_a = this.getImpermaxChef()._address) !== null && _a !== void 0 ? _a : "").toLowerCase();
+        });
+    }
+    getFarmingPool() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.hasFarming()) || (yield this.hasImpermaxChef()))
+                return null;
+            return this.getContractHelper().newFarmingPool(yield this.getBorrowTracker());
+        });
+    }
+    initializeRewarder() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenAddress = yield this.getPoolTokenAddress();
+            try {
+                const { rewarder } = yield this.getImpermaxChef().methods.poolInfo(poolTokenAddress).call();
+                if (rewarder == "0x0000000000000000000000000000000000000000")
+                    return null;
+                return this.getContractHelper().newImpermaxChef(rewarder);
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
+    getRewarder() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.rewarder)
+                this.borrowableCache.rewarder = this.initializeRewarder();
+            return this.borrowableCache.rewarder;
+        });
+    }
+    hasRewarder() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getRewarder()) !== null;
+        });
+    }
+    initializeRewarderTokenSymbol() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.hasRewarder()))
+                return "";
+            const rewarder = yield this.getRewarder();
+            const rewardTokenAddress = yield rewarder.methods.rewardToken().call();
+            return this.getContractHelper().newERC20(rewardTokenAddress).methods.symbol().call();
+        });
+    }
+    getRewarderTokenSymbol() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.rewarderTokenSymbol)
+                this.borrowableCache.rewarderTokenSymbol = this.initializeRewarderTokenSymbol();
+            return this.borrowableCache.rewarderTokenSymbol;
+        });
+    }
+}
+exports.default = Borrowable;

package/lib/impermax-router/Collateral.d.ts

@@ -0,0 +1,9 @@
+import { Contract } from "./types";
+import PoolToken from "./PoolToken";
+export default class Collateral extends PoolToken {
+    collateralCache: {};
+    cleanCache(): void;
+    initializePoolToken(): Promise<Contract>;
+    initializeToken(): Promise<Contract>;
+    protected initializeExchangeRate(): Promise<number>;
+}