impermax-sdk 1.2.112 → 2.0.0

package/lib/onchain/impermaxFactory/lendingPool/borrowable.js

@@ -0,0 +1,153 @@
+"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 Borrowable extends poolToken_1.default {
+    constructor(lendingPool, poolTokenType) {
+        super();
+        this.borrowableCache = {};
+        this.getContractHelper = () => this.lendingPool.factory.onchain.contractsHelper;
+        // Impermax Chef
+        this.getImpermaxChef = () => this.getContractHelper().impermaxChef;
+        this.lendingPool = lendingPool;
+        this.poolTokenType = poolTokenType;
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.borrowableCache = {};
+    }
+    getPoolTokenAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.lendingPool.getPoolTokenAddresses())[this.poolTokenType];
+        });
+    }
+    getOffchainPoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.lendingPool.getOffchainLendingPool();
+            return lendingPool.poolTokens[this.poolTokenType];
+        });
+    }
+    initializePoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getContractHelper().newBorrowable(yield this.getPoolTokenAddress());
+        });
+    }
+    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* () {
+            // remove old farming contracts, now it only has farming if it has the impermaxChef
+            return this.hasImpermaxChef();
+        });
+    }
+    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();
+        });
+    }
+    initializeFarmingTokenSymbol() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.hasImpermaxChef()))
+                return "";
+            const impermaxChef = yield this.getImpermaxChef();
+            const farmingTokenAddress = yield impermaxChef.methods.rewardToken().call();
+            return this.getContractHelper().newERC20(farmingTokenAddress).methods.symbol().call();
+        });
+    }
+    getFarmingTokenSymbol() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.farmingTokenSymbol)
+                this.borrowableCache.farmingTokenSymbol = this.initializeFarmingTokenSymbol();
+            return this.borrowableCache.farmingTokenSymbol;
+        });
+    }
+    // Farming Pool Rewarder
+    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/onchain/impermaxFactory/lendingPool/collateral.d.ts

@@ -0,0 +1,17 @@
+import { Contract } from "../../types";
+import LendingPool from './index';
+import { Address, PoolTokenType } from '../../../config/types';
+import * as offchain from '../../../offchain';
+import PoolToken from '../../poolToken';
+export default class Collateral extends PoolToken {
+    lendingPool: LendingPool;
+    collateralCache: {};
+    constructor(lendingPool: LendingPool, poolTokenType: PoolTokenType);
+    cleanCache(): void;
+    getContractHelper: () => import("../..").ContractsHelper;
+    getPoolTokenAddress(): Promise<Address>;
+    getOffchainPoolToken(): Promise<offchain.lendingPool.OffchainCollateral>;
+    initializePoolToken(): Promise<Contract>;
+    initializeToken(): Promise<Contract>;
+    protected initializeExchangeRate(): Promise<number>;
+}

package/lib/onchain/impermaxFactory/lendingPool/collateral.js

@@ -0,0 +1,59 @@
+"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"));
+class Collateral extends poolToken_1.default {
+    constructor(lendingPool, poolTokenType) {
+        super();
+        this.collateralCache = {};
+        this.getContractHelper = () => this.lendingPool.factory.onchain.contractsHelper;
+        this.lendingPool = lendingPool;
+        this.poolTokenType = poolTokenType;
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.collateralCache = {};
+    }
+    getPoolTokenAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.lendingPool.getPoolTokenAddresses())[this.poolTokenType];
+        });
+    }
+    getOffchainPoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.lendingPool.getOffchainLendingPool();
+            return lendingPool.poolTokens[this.poolTokenType];
+        });
+    }
+    initializePoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getContractHelper().newCollateral(yield this.getPoolTokenAddress());
+        });
+    }
+    initializeToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.lendingPool.getUniswapV2Pair();
+        });
+    }
+    initializeExchangeRate() {
+        const _super = Object.create(null, {
+            initializeExchangeRate: { get: () => super.initializeExchangeRate }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            let exchangeRate = yield _super.initializeExchangeRate.call(this);
+            return exchangeRate * (yield this.lendingPool.getStakedLPExchangeRate());
+        });
+    }
+}
+exports.default = Collateral;

package/lib/onchain/impermaxFactory/lendingPool/index.d.ts

@@ -1,5 +1,12 @@
-import OnchainCollateral from "./onchainCollateral";
-import OnchainBorrowable from "./onchainBorrowable";
-import OnchainLendingPool from './onchainLendingPool';
-export { OnchainBorrowable, OnchainCollateral, };
-export default OnchainLendingPool;
+import * as nftlp from './nftlp';
+import OnchainCollateral from "./onchainCollateral";
+import OnchainBorrowable from "./onchainBorrowable";
+import OnchainLendingPool from './onchainLendingPool';
+import OnchainLendingPoolV2 from "./onchainLendingPoolV2";
+import OnchainBorrowableV2 from "./onchainBorrowableV2";
+import OnchainCollateralV2 from "./onchainCollateralV2";
+import OnchainLendingPoolV3 from "./onchainLendingPoolV3";
+import OnchainBorrowableV3 from "./onchainBorrowableV3";
+import OnchainCollateralV3 from "./onchainCollateralV3";
+export { nftlp, OnchainBorrowable, OnchainCollateral, OnchainLendingPool, OnchainLendingPoolV2, OnchainBorrowableV2, OnchainCollateralV2, OnchainLendingPoolV3, OnchainBorrowableV3, OnchainCollateralV3, };
+export default OnchainLendingPool;

package/lib/onchain/impermaxFactory/lendingPool/index.js

@@ -1,12 +1,50 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnchainCollateral = exports.OnchainBorrowable = void 0;
-const onchainCollateral_1 = __importDefault(require("./onchainCollateral"));
-exports.OnchainCollateral = onchainCollateral_1.default;
-const onchainBorrowable_1 = __importDefault(require("./onchainBorrowable"));
-exports.OnchainBorrowable = onchainBorrowable_1.default;
-const onchainLendingPool_1 = __importDefault(require("./onchainLendingPool"));
-exports.default = onchainLendingPool_1.default;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnchainCollateralV3 = exports.OnchainBorrowableV3 = exports.OnchainLendingPoolV3 = exports.OnchainCollateralV2 = exports.OnchainBorrowableV2 = exports.OnchainLendingPoolV2 = exports.OnchainLendingPool = exports.OnchainCollateral = exports.OnchainBorrowable = exports.nftlp = void 0;
+const nftlp = __importStar(require("./nftlp"));
+exports.nftlp = nftlp;
+const onchainCollateral_1 = __importDefault(require("./onchainCollateral"));
+exports.OnchainCollateral = onchainCollateral_1.default;
+const onchainBorrowable_1 = __importDefault(require("./onchainBorrowable"));
+exports.OnchainBorrowable = onchainBorrowable_1.default;
+const onchainLendingPool_1 = __importDefault(require("./onchainLendingPool"));
+exports.OnchainLendingPool = onchainLendingPool_1.default;
+const onchainLendingPoolV2_1 = __importDefault(require("./onchainLendingPoolV2"));
+exports.OnchainLendingPoolV2 = onchainLendingPoolV2_1.default;
+const onchainBorrowableV2_1 = __importDefault(require("./onchainBorrowableV2"));
+exports.OnchainBorrowableV2 = onchainBorrowableV2_1.default;
+const onchainCollateralV2_1 = __importDefault(require("./onchainCollateralV2"));
+exports.OnchainCollateralV2 = onchainCollateralV2_1.default;
+const onchainLendingPoolV3_1 = __importDefault(require("./onchainLendingPoolV3"));
+exports.OnchainLendingPoolV3 = onchainLendingPoolV3_1.default;
+const onchainBorrowableV3_1 = __importDefault(require("./onchainBorrowableV3"));
+exports.OnchainBorrowableV3 = onchainBorrowableV3_1.default;
+const onchainCollateralV3_1 = __importDefault(require("./onchainCollateralV3"));
+exports.OnchainCollateralV3 = onchainCollateralV3_1.default;
+exports.default = onchainLendingPool_1.default;

package/lib/onchain/impermaxFactory/lendingPool/nftlp/index.d.ts

@@ -0,0 +1,4 @@
+import OnchainNftlp from './onchainNftlp';
+import OnchainNftlpUniswapV3 from './onchainNftlpUniswapV3';
+export { OnchainNftlp, OnchainNftlpUniswapV3, };
+export default OnchainNftlp;

package/lib/onchain/impermaxFactory/lendingPool/nftlp/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnchainNftlpUniswapV3 = exports.OnchainNftlp = void 0;
+const onchainNftlp_1 = __importDefault(require("./onchainNftlp"));
+exports.OnchainNftlp = onchainNftlp_1.default;
+const onchainNftlpUniswapV3_1 = __importDefault(require("./onchainNftlpUniswapV3"));
+exports.OnchainNftlpUniswapV3 = onchainNftlpUniswapV3_1.default;
+exports.default = onchainNftlp_1.default;

package/lib/onchain/impermaxFactory/lendingPool/nftlp/onchainNftlp.d.ts

@@ -0,0 +1,22 @@
+import OnchainLendingPoolV3 from "../onchainLendingPoolV3";
+import { Contract } from "../../../onchainTypes";
+import { OnchainAccountLendingPoolV3 } from "../../../account/lendingPool";
+import OnchainAccountNftlp from "../../../account/lendingPool/nftlp";
+import { OnchainInteractionsLendingPoolV3 } from "../../../interactions/lendingPool";
+import OnchainInteractionsNftlp from "../../../interactions/lendingPool/nftlp";
+export default abstract class OnchainNftlp {
+    protected readonly lendingPool: OnchainLendingPoolV3;
+    protected cache: {
+        nftlp?: Contract;
+    };
+    abstract getNewAccountNftlpObject(accountLendingPool: OnchainAccountLendingPoolV3): OnchainAccountNftlp;
+    abstract getNewInteractionsNftlpObject(accountLendingPool: OnchainInteractionsLendingPoolV3): OnchainInteractionsNftlp;
+    constructor(lendingPool: OnchainLendingPoolV3);
+    cleanCache(): void;
+    protected getContractHelper: () => import("../../..").OnchainContractsHelper;
+    getNftlpAddress: () => string;
+    protected abstract initializeNftlp(): Contract;
+    getNftlp(): any;
+    abstract getMarketPrice(): Promise<number>;
+    abstract getOraclePrice(): Promise<number>;
+}

package/lib/onchain/impermaxFactory/lendingPool/nftlp/onchainNftlp.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OnchainNftlp {
+    constructor(lendingPool) {
+        this.cache = {};
+        this.getContractHelper = () => this.lendingPool.getImpermaxFactory().getOnchain().getContractHelper();
+        this.getNftlpAddress = () => this.lendingPool.getId();
+        this.lendingPool = lendingPool;
+    }
+    cleanCache() {
+        this.cache = {};
+    }
+    getNftlp() {
+        if (!this.cache.nftlp)
+            this.cache.nftlp = this.initializeNftlp();
+        return this.cache.nftlp;
+    }
+}
+exports.default = OnchainNftlp;

package/lib/onchain/impermaxFactory/lendingPool/nftlp/onchainNftlpUniswapV3.d.ts

@@ -0,0 +1,24 @@
+import OnchainNftlp from "./onchainNftlp";
+import { Contract } from "../../../onchainTypes";
+import { OnchainAccountLendingPoolV3 } from "../../../account/lendingPool";
+import { OnchainAccountNftlpUniswapV3 } from "../../../account/lendingPool/nftlp";
+import { OnchainInteractionsNftlpUniswapV3 } from "../../../interactions/lendingPool/nftlp";
+import { OnchainInteractionsLendingPoolV3 } from "../../../interactions/lendingPool";
+export default class OnchainNftlpUniswapV3 extends OnchainNftlp {
+    protected cache: {
+        nftlp?: Contract;
+        uniswapV3Pools?: {
+            [key in number]: Promise<Contract | null>;
+        };
+        marketPrice?: Promise<number>;
+        oraclePrice?: Promise<number>;
+    };
+    getNewAccountNftlpObject(accountNftlp: OnchainAccountLendingPoolV3): OnchainAccountNftlpUniswapV3;
+    getNewInteractionsNftlpObject(interactionsNftlp: OnchainInteractionsLendingPoolV3): OnchainInteractionsNftlpUniswapV3;
+    initializeNftlp(): any;
+    initializeUniswapV3Pool(fee: number): Promise<Contract | null>;
+    getUniswapV3Pool(fee: number): Promise<any>;
+    getMarketPrice(): Promise<number>;
+    private initializeOraclePrice;
+    getOraclePrice(): Promise<number>;
+}

package/lib/onchain/impermaxFactory/lendingPool/nftlp/onchainNftlpUniswapV3.js

@@ -0,0 +1,90 @@
+"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 onchainNftlp_1 = __importDefault(require("./onchainNftlp"));
+const nftlp_1 = require("../../../account/lendingPool/nftlp");
+const nftlp_2 = require("../../../interactions/lendingPool/nftlp");
+const FEES = [
+    100,
+    500,
+    3000,
+    10000,
+];
+class OnchainNftlpUniswapV3 extends onchainNftlp_1.default {
+    constructor() {
+        super(...arguments);
+        this.cache = {};
+    }
+    getNewAccountNftlpObject(accountNftlp) {
+        return new nftlp_1.OnchainAccountNftlpUniswapV3(accountNftlp);
+    }
+    getNewInteractionsNftlpObject(interactionsNftlp) {
+        return new nftlp_2.OnchainInteractionsNftlpUniswapV3(interactionsNftlp);
+    }
+    initializeNftlp() {
+        return this.getContractHelper().newNftlpUniV3(this.getNftlpAddress());
+    }
+    initializeUniswapV3Pool(fee) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nftlp = this.getNftlp();
+            try {
+                const poolAddress = yield nftlp.methods.getPool(fee).call();
+                return this.getContractHelper().newUniswapV3Pool(poolAddress);
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
+    getUniswapV3Pool(fee) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.uniswapV3Pools)
+                this.cache.uniswapV3Pools = {};
+            if (!this.cache.uniswapV3Pools[fee])
+                this.cache.uniswapV3Pools[fee] = this.initializeUniswapV3Pool(fee);
+            return this.cache.uniswapV3Pools[fee];
+        });
+    }
+    getMarketPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let priceCumulative = 0;
+            let liquidityCumulative = 0;
+            for (const fee of FEES) {
+                const pool = yield this.getUniswapV3Pool(fee);
+                if (!pool)
+                    continue;
+                const price = Math.pow(((yield pool.methods.slot0().call()).sqrtPriceX96 / Math.pow(2, 96)), 2);
+                const liquidity = (yield pool.methods.liquidity().call()) * 1;
+                priceCumulative += price * liquidity;
+                liquidityCumulative += liquidity;
+            }
+            return priceCumulative / liquidityCumulative;
+        });
+    }
+    ;
+    initializeOraclePrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nftlp = yield this.getNftlp();
+            return Math.pow((nftlp.methods.oraclePriceSqrtX96().call() / Math.pow(2, 96)), 2);
+        });
+    }
+    getOraclePrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.oraclePrice)
+                this.cache.oraclePrice = this.initializeOraclePrice();
+            return this.cache.oraclePrice;
+        });
+    }
+}
+exports.default = OnchainNftlpUniswapV3;

package/lib/onchain/impermaxFactory/lendingPool/onchainBorrowable.d.ts

@@ -1,34 +1,38 @@
-import { Contract } from "../../onchainTypes";
-import { Address, PoolTokenType } from '../../../config/types';
-import OnchainLendingPool from './index';
-import OnchainPoolToken from '../../onchainPoolToken';
-import OffchainBorrowable from '../../../offchain/lendingPool/offchainBorrowable';
-export default class OnchainBorrowable extends OnchainPoolToken {
-    private readonly lendingPool;
-    private readonly poolTokenType;
-    private borrowableCache;
-    constructor(lendingPool: OnchainLendingPool, poolTokenType: PoolTokenType);
-    getLendingPool: () => OnchainLendingPool;
-    getPoolTokenType: () => PoolTokenType;
-    cleanCache(): void;
-    private getContractHelper;
-    getPoolTokenAddress(): Promise<Address>;
-    getOffchainPoolToken(): Promise<OffchainBorrowable>;
-    getOffchainBorrowable: () => Promise<OffchainBorrowable>;
-    protected initializePoolToken(): Promise<Contract>;
-    protected initializeToken(): Promise<Contract>;
-    getPriceDenomLP(): Promise<number>;
-    getMarketPriceDenomLP(): Promise<number>;
-    private initializeBorrowTracker;
-    getBorrowTracker(): Promise<string>;
-    hasFarming(): Promise<boolean>;
-    getImpermaxChef: () => any;
-    hasImpermaxChef(): Promise<boolean>;
-    private initializeFarmingTokenSymbol;
-    getFarmingTokenSymbol(): Promise<string>;
-    private initializeRewarder;
-    getRewarder(): Promise<any>;
-    hasRewarder(): Promise<boolean>;
-    private initializeRewarderTokenSymbol;
-    getRewarderTokenSymbol(): Promise<string>;
-}
+import { Contract } from "../../onchainTypes";
+import { Address, Borrowable } from '../../../config/types';
+import OnchainLendingPool from './index';
+import OnchainPoolToken from '../../onchainPoolToken';
+import OffchainBorrowable from '../../../offchain/lendingPool/offchainBorrowable';
+export default abstract class OnchainBorrowable extends OnchainPoolToken {
+    protected readonly lendingPool: OnchainLendingPool;
+    protected readonly borrowable: Borrowable;
+    protected borrowableCache: {
+        borrowTracker?: Promise<Address>;
+        rewarder?: Promise<Contract>;
+        rewarderTokenSymbol?: Promise<string>;
+        farmingTokenSymbol?: Promise<string>;
+        rewardSpeed?: Promise<number>;
+    };
+    constructor(lendingPool: OnchainLendingPool, borrowable: Borrowable);
+    getLendingPool: () => OnchainLendingPool;
+    getBorrowableType: () => Borrowable;
+    cleanCache(): void;
+    protected getContractHelper: () => import("../..").OnchainContractsHelper;
+    getPoolTokenAddress(): Promise<Address>;
+    getOffchainPoolToken(): Promise<OffchainBorrowable>;
+    getOffchainBorrowable: () => Promise<OffchainBorrowable>;
+    protected abstract initializePoolToken(): Promise<Contract>;
+    protected initializeToken(): Promise<Contract>;
+    private initializeBorrowTracker;
+    getBorrowTracker(): Promise<string>;
+    hasFarming(): Promise<boolean>;
+    getImpermaxChef: () => any;
+    hasImpermaxChef(): Promise<boolean>;
+    private initializeFarmingTokenSymbol;
+    getFarmingTokenSymbol(): Promise<string>;
+    private initializeRewarder;
+    getRewarder(): Promise<any>;
+    hasRewarder(): Promise<boolean>;
+    private initializeRewarderTokenSymbol;
+    getRewarderTokenSymbol(): Promise<string>;
+}