impermax-sdk 1.2.112 → 2.0.0

package/lib/offchain/lendingPool/borrowable.js

@@ -0,0 +1,351 @@
+"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 utils_1 = require("../../utils");
+const imxes_1 = require("../../config/contracts/imxes");
+const poolToken_1 = __importDefault(require("../poolToken"));
+class Borrowable extends poolToken_1.default {
+    constructor(lendingPool, poolTokenType) {
+        super();
+        this.getOffchain = () => this.lendingPool.offchain;
+        this.lendingPool = lendingPool;
+        this.poolTokenType = poolTokenType;
+    }
+    getPoolTokenData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.lendingPool.getLendingPoolData();
+            return lendingPoolData[this.poolTokenType];
+        });
+    }
+    // Reserve Factor
+    getReserveFactor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("reserveFactor");
+        });
+    }
+    // Kink Borrow Rate
+    getKinkBorrowRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("kinkBorrowRate");
+        });
+    }
+    // Kink Utilization Rate
+    getKinkUtilizationRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("kinkUtilizationRate");
+        });
+    }
+    // Borrow Index
+    getBorrowIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("borrowIndex");
+        });
+    }
+    // Accrue Timestamp
+    getAccrualTimestamp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("accrualTimestamp");
+        });
+    }
+    // Total borrows
+    getTotalBorrows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("totalBorrows");
+        });
+    }
+    getCurrentTotalBorrows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storedAmount = yield this.getTotalBorrows();
+            const accrualTimestamp = yield this.getAccrualTimestamp();
+            const borrowRate = yield this.getBorrowRate();
+            return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * borrowRate);
+        });
+    }
+    getTotalBorrowsUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBorrows = yield this.getCurrentTotalBorrows();
+            const tokenPrice = yield this.getTokenPriceFast();
+            return totalBorrows * tokenPrice;
+        });
+    }
+    // Borrow rate
+    getBorrowRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("borrowRate");
+        });
+    }
+    getBorrowAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowRate = yield this.getBorrowRate();
+            return (0, utils_1.toAPR)(borrowRate);
+        });
+    }
+    getNextBorrowRate(borrowAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBorrows = yield this.getTotalBorrows();
+            const supply = yield this.getSupply();
+            const UR = (borrowAmount + totalBorrows) / supply;
+            const kinkBR = yield this.getKinkBorrowRate();
+            const kinkUR = yield this.getKinkUtilizationRate();
+            if (UR < kinkUR)
+                return UR / kinkUR * kinkBR;
+            const kinkMultiplier = this.lendingPool.getKinkMultiplier();
+            return ((UR - kinkUR) / (1 - kinkUR) * (kinkMultiplier - 1) + 1) * kinkBR;
+        });
+    }
+    getNextBorrowAPR(borrowAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowRate = yield this.getNextBorrowRate(borrowAmount);
+            return (0, utils_1.toAPR)(borrowRate);
+        });
+    }
+    // Supply
+    getSupply() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBalance = yield this.getTotalBalance();
+            const totalBorrows = yield this.getTotalBorrows();
+            return totalBalance + totalBorrows;
+        });
+    }
+    getCurrentSupply() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storedAmount = yield this.getSupply();
+            const accrualTimestamp = yield this.getAccrualTimestamp();
+            const supplyRate = yield this.getSupplyRate();
+            return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * supplyRate);
+        });
+    }
+    getSupplyUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supply = yield this.getCurrentSupply();
+            const tokenPrice = yield this.getTokenPriceFast();
+            return supply * tokenPrice;
+        });
+    }
+    // Utilization Rate
+    getUtilizationRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supply = yield this.getSupply();
+            if (supply == 0)
+                return 0;
+            const totalBalance = yield this.getTotalBorrows();
+            return totalBalance / supply;
+        });
+    }
+    // Supply Rate
+    getSupplyRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowRate = yield this.getBorrowRate();
+            const utilizationRate = yield this.getUtilizationRate();
+            const reserveFactor = yield this.getReserveFactor();
+            return borrowRate * utilizationRate * (1 - reserveFactor);
+        });
+    }
+    getSupplyAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supplyRate = yield this.getSupplyRate();
+            return (0, utils_1.toAPR)(supplyRate);
+        });
+    }
+    getNextSupplyRate(supplyAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBorrows = yield this.getTotalBorrows();
+            const supply = yield this.getSupply();
+            const UR = totalBorrows / (supply + supplyAmount);
+            const kinkBR = yield this.getKinkBorrowRate();
+            const kinkUR = yield this.getKinkUtilizationRate();
+            const reserveFactor = yield this.getReserveFactor();
+            if (UR < kinkUR)
+                return UR / kinkUR * kinkBR * UR * (1 - reserveFactor);
+            const kinkMultiplier = this.lendingPool.getKinkMultiplier();
+            return ((UR - kinkUR) / (1 - kinkUR) * (kinkMultiplier - 1) + 1) * kinkBR * UR * (1 - reserveFactor);
+        });
+    }
+    getNextSupplyAPR(supplyAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supplyRate = yield this.getNextSupplyRate(supplyAmount);
+            return (0, utils_1.toAPR)(supplyRate);
+        });
+    }
+    // Reward Speed
+    getFarmingRewardsRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenData = yield this.getPoolTokenData();
+            const rewards = poolTokenData.rewards;
+            if (rewards && rewards.length > 0)
+                return rewards;
+            const FINISH_DELAY = 3600 * 24;
+            const farmingPoolData = poolTokenData.farmingPool;
+            if (farmingPoolData === null)
+                return [];
+            const segmentLength = parseInt(farmingPoolData.segmentLength);
+            const epochAmount = parseFloat(farmingPoolData.epochAmount);
+            const epochBegin = parseInt(farmingPoolData.epochBegin);
+            const epochEnd = epochBegin + segmentLength;
+            const timestamp = (new Date()).getTime() / 1000;
+            if (timestamp - FINISH_DELAY > epochEnd) {
+                // How to manage better this case? Maybe check shares on distributor
+                return [];
+            }
+            return [{
+                    rewardToken: imxes_1.IMX[this.lendingPool.offchain.network],
+                    rewardRate: epochAmount / segmentLength
+                }];
+        });
+    }
+    // Farming
+    getFarmingRewards() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getNextFarmingRewards(0);
+        });
+    }
+    getNextFarmingRewards(borrowAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const farmingRewards = yield this.getFarmingRewardsRate();
+            const currentBorrowedUSD = yield this.getTotalBorrowsUSD();
+            const tokenPrice = yield this.getTokenPriceFast();
+            const additionalBorrowsUSD = borrowAmount * tokenPrice;
+            const totalBorrowedUSD = currentBorrowedUSD + additionalBorrowsUSD;
+            if (totalBorrowedUSD === 0)
+                return [];
+            const rewards = [];
+            for (const reward of farmingRewards) {
+                const rewardPrice = yield this.lendingPool.offchain.priceHelper.getDebankTokenPrice(reward.rewardToken);
+                rewards.push({
+                    APR: (0, utils_1.toAPR)((rewardPrice * reward.rewardRate) / totalBorrowedUSD),
+                    symbol: reward.rewardToken == "0x98878b06940ae243284ca214f92bb71a2b032b8a" ? "WMOVR" :
+                        reward.rewardToken == "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270" ? "WMATIC" :
+                            reward.rewardToken == "0x6659a9c5cd313974343e30b4fdffd95bd4b4dcd2" ? "IMX" :
+                                reward.rewardToken == "0x7b35ce522cb72e4077baeb96cb923a5529764a00" ? "IMX" :
+                                    reward.rewardToken == "0x60bb3d364b765c497c8ce50ae0ae3f0882c5bd05" ? "IMX" :
+                                        reward.rewardToken == "0x9c67ee39e3c4954396b9142010653f17257dd39c" ? "IMX" :
+                                            reward.rewardToken == "0xea6887e4a9cda1b77e70129e5fba830cdb5cddef" ? "IMX" :
+                                                reward.rewardToken == "0x900f1Ec5819FA087d368877cD03B265Bf1802667" ? "IMX" :
+                                                    reward.rewardToken == "0xea38f1ccf77bf43f352636241b05dd8f6f5f52b2" ? "IMX" :
+                                                        "IBEX",
+                });
+            }
+            return rewards;
+        });
+    }
+    getFarmingAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getNextFarmingAPR(0);
+        });
+    }
+    getNextFarmingAPR(borrowAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rewards = yield this.getNextFarmingRewards(borrowAmount);
+            let APR = 0;
+            for (const reward of rewards) {
+                APR += reward.APR;
+            }
+            return APR;
+        });
+    }
+    // Past Data
+    getPoolTokenDataPast24h() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolDataPast = yield this.lendingPool.getLendingPoolDataPast24h();
+            if (!lendingPoolDataPast)
+                return undefined;
+            return lendingPoolDataPast[this.poolTokenType];
+        });
+    }
+    getPoolTokenDataPast7d() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolDataPast = yield this.lendingPool.getLendingPoolDataPast7d();
+            if (!lendingPoolDataPast)
+                return undefined;
+            return lendingPoolDataPast[this.poolTokenType];
+        });
+    }
+    // Average Borrow APR
+    getAverageBorrowAPR(poolTokenDataPast, fallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (poolTokenDataPast) {
+                const accrualTimestampPast = parseFloat(poolTokenDataPast.accrualTimestamp);
+                const borrowIndexPast = parseFloat(poolTokenDataPast.borrowIndex);
+                const accrualTimestampNow = yield this.getAccrualTimestamp();
+                const borrowIndexNow = yield this.getBorrowIndex();
+                if (accrualTimestampNow > accrualTimestampPast) {
+                    const borrowRate = (borrowIndexNow / borrowIndexPast - 1) / (accrualTimestampNow - accrualTimestampPast);
+                    return borrowRate * 3600 * 24 * 365;
+                }
+            }
+            return fallback;
+        });
+    }
+    getAverage24hBorrowAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenDataPast = yield this.getPoolTokenDataPast24h();
+            return this.getAverageBorrowAPR(poolTokenDataPast, this.getBorrowAPR());
+        });
+    }
+    getAverage7dBorrowAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenDataPast = yield this.getPoolTokenDataPast7d();
+            return this.getAverageBorrowAPR(poolTokenDataPast, this.getAverage24hBorrowAPR());
+        });
+    }
+    // Average Supply APR
+    getAverageSupplyAPR(poolTokenDataPast, fallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (poolTokenDataPast) {
+                const accrualTimestampPast = parseFloat(poolTokenDataPast.accrualTimestamp);
+                const exchangeRatePast = parseFloat(poolTokenDataPast.exchangeRate);
+                const accrualTimestampNow = yield this.getAccrualTimestamp();
+                const exchangeRateNow = yield this.getExchangeRate();
+                if (accrualTimestampNow > accrualTimestampPast) {
+                    const supplyRate = (exchangeRateNow / exchangeRatePast - 1) / (accrualTimestampNow - accrualTimestampPast);
+                    return supplyRate * 3600 * 24 * 365;
+                }
+            }
+            return fallback;
+        });
+    }
+    getAverage24hSupplyAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenDataPast = yield this.getPoolTokenDataPast24h();
+            return this.getAverageSupplyAPR(poolTokenDataPast, this.getSupplyAPR());
+        });
+    }
+    getAverage7dSupplyAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenDataPast = yield this.getPoolTokenDataPast7d();
+            return this.getAverageSupplyAPR(poolTokenDataPast, this.getAverage24hSupplyAPR());
+        });
+    }
+    // Token price getters
+    getTokenPriceFast(fallback = true) {
+        const _super = Object.create(null, {
+            getTokenPriceFast: { get: () => super.getTokenPriceFast }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            let tokenAddress = yield this.getUnderlyingAddress();
+            let tokenPrices = yield this.lendingPool.offchain.priceHelper.getSubgraphTokensPrice();
+            let tokenPrice = tokenPrices[tokenAddress];
+            if (tokenPrice !== undefined && tokenPrice > 0)
+                return tokenPrice;
+            return _super.getTokenPriceFast.call(this, fallback);
+        });
+    }
+    getTokenPriceAccurate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let tokenAddress = yield this.getUnderlyingAddress();
+            return this.lendingPool.offchain.priceHelper.getDebankTokenPrice(tokenAddress);
+        });
+    }
+}
+exports.default = Borrowable;

package/lib/offchain/lendingPool/collateral.d.ts

@@ -0,0 +1,17 @@
+import { PoolTokenData } from "../types";
+import LendingPool from './';
+import { Address, PoolTokenType } from '../../config/types';
+import PoolToken from '../poolToken';
+export default class Collateral extends PoolToken {
+    lendingPool: LendingPool;
+    poolTokenType: PoolTokenType;
+    constructor(lendingPool: LendingPool, poolTokenType: PoolTokenType);
+    getOffchain: () => import("..").default;
+    getPoolTokenData(): Promise<PoolTokenData>;
+    getName(): Promise<string>;
+    getSymbol(): Promise<string>;
+    getDecimals(): Promise<number>;
+    getUnderlyingAddress(): Promise<Address>;
+    getTokenPriceFast(fallback?: boolean): Promise<number>;
+    getTokenPriceAccurate(): Promise<number>;
+}

package/lib/offchain/lendingPool/collateral.js

@@ -0,0 +1,72 @@
+"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("../../config/types");
+const poolToken_1 = __importDefault(require("../poolToken"));
+class Collateral extends poolToken_1.default {
+    constructor(lendingPool, poolTokenType) {
+        super();
+        this.getOffchain = () => this.lendingPool.offchain;
+        this.lendingPool = lendingPool;
+        this.poolTokenType = poolTokenType;
+    }
+    getPoolTokenData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.lendingPool.getLendingPoolData();
+            return lendingPoolData[this.poolTokenType];
+        });
+    }
+    getName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nameA = yield this.lendingPool.poolTokens[types_1.PoolTokenType.BorrowableA].getName();
+            const nameB = yield this.lendingPool.poolTokens[types_1.PoolTokenType.BorrowableB].getName();
+            return nameA + '-' + nameB + ' LP';
+        });
+    }
+    getSymbol() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const symbolA = yield this.lendingPool.poolTokens[types_1.PoolTokenType.BorrowableA].getSymbol();
+            const symbolB = yield this.lendingPool.poolTokens[types_1.PoolTokenType.BorrowableB].getSymbol();
+            return symbolA + '-' + symbolB;
+        });
+    }
+    getDecimals() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 18;
+        });
+    }
+    getUnderlyingAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.lendingPool.pairAddress;
+        });
+    }
+    // Token price getters
+    getTokenPriceFast(fallback = true) {
+        const _super = Object.create(null, {
+            getTokenPriceFast: { get: () => super.getTokenPriceFast }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            let tokenPrice = yield this.lendingPool.getCollateralPrice(false);
+            if (tokenPrice > 0)
+                return tokenPrice;
+            return _super.getTokenPriceFast.call(this, fallback);
+        });
+    }
+    getTokenPriceAccurate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.lendingPool.getCollateralPrice(false);
+        });
+    }
+}
+exports.default = Collateral;

package/lib/offchain/lendingPool/index.d.ts

@@ -1,5 +1,5 @@
-import OffchainCollateral from './offchainCollateral';
-import OffchainBorrowable from './offchainBorrowable';
-import OffchainLendingPool from './offchainLendingPool';
-export { OffchainBorrowable, OffchainCollateral, };
-export default OffchainLendingPool;
+import OffchainCollateral from './offchainCollateral';
+import OffchainBorrowable from './offchainBorrowable';
+import OffchainLendingPool from './offchainLendingPool';
+export { OffchainBorrowable, OffchainCollateral, };
+export default OffchainLendingPool;

package/lib/offchain/lendingPool/index.js

@@ -1,12 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OffchainCollateral = exports.OffchainBorrowable = void 0;
-const offchainCollateral_1 = __importDefault(require("./offchainCollateral"));
-exports.OffchainCollateral = offchainCollateral_1.default;
-const offchainBorrowable_1 = __importDefault(require("./offchainBorrowable"));
-exports.OffchainBorrowable = offchainBorrowable_1.default;
-const offchainLendingPool_1 = __importDefault(require("./offchainLendingPool"));
-exports.default = offchainLendingPool_1.default;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffchainCollateral = exports.OffchainBorrowable = void 0;
+const offchainCollateral_1 = __importDefault(require("./offchainCollateral"));
+exports.OffchainCollateral = offchainCollateral_1.default;
+const offchainBorrowable_1 = __importDefault(require("./offchainBorrowable"));
+exports.OffchainBorrowable = offchainBorrowable_1.default;
+const offchainLendingPool_1 = __importDefault(require("./offchainLendingPool"));
+exports.default = offchainLendingPool_1.default;

package/lib/offchain/lendingPool/offchainBorrowable.d.ts

@@ -1,59 +1,59 @@
-import { BorrowablePastData, PoolTokenData } from "../offchainTypes";
-import { Address, PoolTokenType } from '../../config/types';
-import OffchainPoolToken from '../offchainPoolToken';
-import OffchainLendingPool from './offchainLendingPool';
-export default class OffchainBorrowable extends OffchainPoolToken {
-    private readonly lendingPool;
-    private readonly poolTokenType;
-    constructor(lendingPool: OffchainLendingPool, poolTokenType: PoolTokenType);
-    getOffchain: () => import("..").default;
-    getLendingPool: () => OffchainLendingPool;
-    getPoolTokenType: () => PoolTokenType;
-    getPoolTokenData(): Promise<PoolTokenData>;
-    getReserveFactor(): Promise<number>;
-    getKinkBorrowRate(): Promise<number>;
-    getKinkUtilizationRate(): Promise<number>;
-    getAdjustSpeed(): Promise<number>;
-    getBorrowTracker(): Promise<Address>;
-    getBorrowIndex(): Promise<number>;
-    getAccrualTimestamp(): Promise<number>;
-    getTotalBorrows(): Promise<number>;
-    getCurrentTotalBorrows(): Promise<number>;
-    getTotalBorrowsUSD(): Promise<number>;
-    getBorrowRate(): Promise<number>;
-    getBorrowAPR(): Promise<number>;
-    getNextBorrowRate(borrowAmount: number): Promise<number>;
-    getNextBorrowAPR(borrowAmount: number): Promise<number>;
-    getSupply(): Promise<number>;
-    getCurrentSupply(): Promise<number>;
-    getSupplyUSD(): Promise<number>;
-    getUtilizationRate(): Promise<number>;
-    getSupplyRate(): Promise<number>;
-    getSupplyAPR(): Promise<number>;
-    getNextSupplyRate(supplyAmount: number): Promise<number>;
-    getNextSupplyAPR(supplyAmount: number): Promise<number>;
-    getFarmingRewardsRate(): Promise<Array<{
-        rewardToken: string;
-        rewardRate: number;
-    }>>;
-    getFarmingRewards(): Promise<Array<{
-        APR: number;
-        symbol: string;
-    }>>;
-    getNextFarmingRewards(borrowAmount: number): Promise<Array<{
-        APR: number;
-        symbol: string;
-    }>>;
-    getFarmingAPR(): Promise<number>;
-    getNextFarmingAPR(borrowAmount: number): Promise<number>;
-    getPoolTokenDataPast24h(): Promise<BorrowablePastData | undefined>;
-    getPoolTokenDataPast7d(): Promise<BorrowablePastData | undefined>;
-    private getAverageBorrowAPR;
-    getAverage24hBorrowAPR(): Promise<number>;
-    getAverage7dBorrowAPR(): Promise<number>;
-    private getAverageSupplyAPR;
-    getAverage24hSupplyAPR(): Promise<number>;
-    getAverage7dSupplyAPR(): Promise<number>;
-    getTokenPriceFast(fallback?: boolean): Promise<number>;
-    getTokenPriceAccurate(): Promise<number>;
-}
+import { BorrowablePastData, PoolTokenData } from "../offchainTypes";
+import { Address, PoolTokenType } from '../../config/types';
+import OffchainPoolToken from '../offchainPoolToken';
+import OffchainLendingPool from './offchainLendingPool';
+export default class OffchainBorrowable extends OffchainPoolToken {
+    private readonly lendingPool;
+    private readonly poolTokenType;
+    constructor(lendingPool: OffchainLendingPool, poolTokenType: PoolTokenType);
+    getOffchain: () => import("..").default;
+    getLendingPool: () => OffchainLendingPool;
+    getPoolTokenType: () => PoolTokenType;
+    getPoolTokenData(): Promise<PoolTokenData>;
+    getReserveFactor(): Promise<number>;
+    getKinkBorrowRate(): Promise<number>;
+    getKinkUtilizationRate(): Promise<number>;
+    getAdjustSpeed(): Promise<number>;
+    getBorrowTracker(): Promise<Address>;
+    getBorrowIndex(): Promise<number>;
+    getAccrualTimestamp(): Promise<number>;
+    getTotalBorrows(): Promise<number>;
+    getCurrentTotalBorrows(): Promise<number>;
+    getTotalBorrowsUSD(): Promise<number>;
+    getBorrowRate(): Promise<number>;
+    getBorrowAPR(): Promise<number>;
+    getNextBorrowRate(borrowAmount: number): Promise<number>;
+    getNextBorrowAPR(borrowAmount: number): Promise<number>;
+    getSupply(): Promise<number>;
+    getCurrentSupply(): Promise<number>;
+    getSupplyUSD(): Promise<number>;
+    getUtilizationRate(): Promise<number>;
+    getSupplyRate(): Promise<number>;
+    getSupplyAPR(): Promise<number>;
+    getNextSupplyRate(supplyAmount: number): Promise<number>;
+    getNextSupplyAPR(supplyAmount: number): Promise<number>;
+    getFarmingRewardsRate(): Promise<Array<{
+        rewardToken: string;
+        rewardRate: number;
+    }>>;
+    getFarmingRewards(): Promise<Array<{
+        APR: number;
+        symbol: string;
+    }>>;
+    getNextFarmingRewards(borrowAmount: number): Promise<Array<{
+        APR: number;
+        symbol: string;
+    }>>;
+    getFarmingAPR(): Promise<number>;
+    getNextFarmingAPR(borrowAmount: number): Promise<number>;
+    getPoolTokenDataPast24h(): Promise<BorrowablePastData | undefined>;
+    getPoolTokenDataPast7d(): Promise<BorrowablePastData | undefined>;
+    private getAverageBorrowAPR;
+    getAverage24hBorrowAPR(): Promise<number>;
+    getAverage7dBorrowAPR(): Promise<number>;
+    private getAverageSupplyAPR;
+    getAverage24hSupplyAPR(): Promise<number>;
+    getAverage7dSupplyAPR(): Promise<number>;
+    getTokenPriceFast(fallback?: boolean): Promise<number>;
+    getTokenPriceAccurate(): Promise<number>;
+}