impermax-sdk 1.2.112 → 2.0.0

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

@@ -1,58 +1,43 @@
-import OnchainImpermaxFactory from '../index';
-import { Address, PoolTokenType } from '../../../config/types';
-import OnchainCollateral from './onchainCollateral';
-import OnchainBorrowable from './onchainBorrowable';
-import { PendingRewardUI } from '../../onchainTypes';
-import OnchainPoolToken from '../../onchainPoolToken';
-export default class OnchainLendingPool {
-    private readonly impermaxFactory;
-    private readonly pairAddress;
-    private readonly poolTokens;
-    private cache;
-    constructor(impermaxFactory: OnchainImpermaxFactory, pairAddress: Address);
-    getImpermaxFactory: () => OnchainImpermaxFactory;
-    getPairAddress: () => string;
-    getPoolToken(poolTokenType: PoolTokenType): OnchainPoolToken;
-    getBorrowableA: () => OnchainBorrowable;
-    getBorrowableB: () => OnchainBorrowable;
-    getCollateral: () => OnchainCollateral;
-    private getContractHelper;
-    cleanCache(): void;
-    getOffchainLendingPool(): Promise<import("../../..").OffchainLendingPool>;
-    private initializePoolTokenAddresses;
-    getPoolTokenAddresses(): Promise<{
-        collateral: string;
-        borrowable0: string;
-        borrowable1: string;
-    }>;
-    private initializeIsStakedLPToken;
-    getIsStakedLPToken(): Promise<boolean>;
-    private initializeStakedLPToken;
-    getStakedLPToken(): Promise<any>;
-    private initializeUniswapV2Pair;
-    getUniswapV2Pair(): Promise<any>;
-    private initializeReserves;
-    getReserves(): Promise<[number, number]>;
-    private initializeLPTotalSupply;
-    getLPTotalSupply(): Promise<number>;
-    private initializePriceDenomLP;
-    getPriceDenomLP(): Promise<[number, number]>;
-    getMarketPriceDenomLP(): Promise<[number, number]>;
-    getMarketPrice(): Promise<number>;
-    private initializeTwapReservesValueRatio;
-    getTwapReservesValueRatio(): Promise<number>;
-    getTwapReservesWeights(): Promise<[number, number]>;
-    private initializeMarketReservesValueRatio;
-    getMarketReservesValueRatio(): Promise<number>;
-    getMarketReservesWeights(): Promise<[number, number]>;
-    private initializeTWAPPrice;
-    getTWAPPrice(): Promise<number>;
-    private initializeStakedLPExchangeRate;
-    getStakedLPExchangeRate(): Promise<number>;
-    private initializePendingReward;
-    getPendingReward(): Promise<PendingRewardUI | null>;
-    private initializeReinvestBountyFactor;
-    getReinvestBountyFactor(): Promise<number>;
-    getReinvestBounty(): Promise<number>;
-    hasFarming(): Promise<boolean>;
-}
+import OnchainImpermaxFactory from '../index';
+import { Address, Borrowable } from '../../../config/types';
+import OnchainCollateral from './onchainCollateral';
+import OnchainBorrowable from './onchainBorrowable';
+import OnchainAccountLendingPool from "../../account/lendingPool";
+import OnchainInteractions, { OnchainInteractionsLendingPool } from "../../interactions";
+import OnchainAccount from "../../account";
+export default abstract class OnchainLendingPool {
+    protected readonly id: Address;
+    protected readonly impermaxFactory: OnchainImpermaxFactory;
+    protected readonly collateral: OnchainCollateral;
+    protected readonly borrowables: {
+        [Borrowable.A]: OnchainBorrowable;
+        [Borrowable.B]: OnchainBorrowable;
+    };
+    protected cache: {
+        lendingPoolAddresses?: Promise<{
+            collateral: Address;
+            borrowables: {
+                [key in Borrowable]: Address;
+            };
+        }>;
+    };
+    protected abstract getNewCollateralObject(): OnchainCollateral;
+    protected abstract getNewBorrowableObject(borrowable: Borrowable): OnchainBorrowable;
+    abstract getNewAccountLendingPoolObject(account: OnchainAccount): OnchainAccountLendingPool;
+    abstract getNewInteractionLendingPoolObject(interactions: OnchainInteractions): OnchainInteractionsLendingPool;
+    constructor(impermaxFactory: OnchainImpermaxFactory, id: Address);
+    getImpermaxFactory: () => OnchainImpermaxFactory;
+    getId: () => string;
+    getBorrowable: (borrowable: Borrowable) => OnchainBorrowable;
+    getBorrowableA: () => OnchainBorrowable;
+    getBorrowableB: () => OnchainBorrowable;
+    getCollateral: () => OnchainCollateral;
+    protected getContractHelper: () => import("../..").OnchainContractsHelper;
+    cleanCache(): void;
+    getOffchainLendingPool(): Promise<import("../../..").OffchainLendingPool>;
+    private initializeLendingPoolAddresses;
+    private getLendingPoolAddresses;
+    getCollateralAddress(): Promise<string>;
+    getBorrowableAddress(borrowable: Borrowable): Promise<string>;
+    hasFarming(): Promise<boolean>;
+}

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

@@ -1,367 +1,81 @@
-"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 onchainCollateral_1 = __importDefault(require("./onchainCollateral"));
-const onchainBorrowable_1 = __importDefault(require("./onchainBorrowable"));
-const factories_1 = require("../../../config/factories");
-const lliquidity_math_1 = require("../../../utils/lliquidity-math");
-class OnchainLendingPool {
-    constructor(impermaxFactory, pairAddress) {
-        this.cache = {};
-        this.getImpermaxFactory = () => this.impermaxFactory;
-        this.getPairAddress = () => this.pairAddress;
-        // Shortcuts
-        this.getBorrowableA = () => this.poolTokens[types_1.PoolTokenType.BorrowableA];
-        this.getBorrowableB = () => this.poolTokens[types_1.PoolTokenType.BorrowableB];
-        this.getCollateral = () => this.poolTokens[types_1.PoolTokenType.Collateral];
-        this.getContractHelper = () => this.impermaxFactory.getOnchain().getContractHelper();
-        this.impermaxFactory = impermaxFactory;
-        this.pairAddress = pairAddress;
-        this.poolTokens = {
-            [types_1.PoolTokenType.Collateral]: new onchainCollateral_1.default(this),
-            [types_1.PoolTokenType.BorrowableA]: new onchainBorrowable_1.default(this, types_1.PoolTokenType.BorrowableA),
-            [types_1.PoolTokenType.BorrowableB]: new onchainBorrowable_1.default(this, types_1.PoolTokenType.BorrowableB),
-        };
-    }
-    getPoolToken(poolTokenType) {
-        return this.poolTokens[poolTokenType];
-    }
-    cleanCache() {
-        this.cache = {};
-        this.getBorrowableA().cleanCache();
-        this.getBorrowableB().cleanCache();
-        this.getCollateral().cleanCache();
-    }
-    getOffchainLendingPool() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.impermaxFactory.getOnchain().getOffchain().getLendingPool(this.impermaxFactory.getFactory(), this.pairAddress);
-        });
-    }
-    initializePoolTokenAddresses() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const lPool = yield this.impermaxFactory.getRouter().methods.getLendingPool(this.pairAddress).call();
-            return {
-                [types_1.PoolTokenType.Collateral]: lPool.collateral,
-                [types_1.PoolTokenType.BorrowableA]: lPool.borrowableA,
-                [types_1.PoolTokenType.BorrowableB]: lPool.borrowableB,
-            };
-        });
-    }
-    getPoolTokenAddresses() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.poolTokenAddresses)
-                this.cache.poolTokenAddresses = this.initializePoolTokenAddresses();
-            return this.cache.poolTokenAddresses;
-        });
-    }
-    initializeIsStakedLPToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.impermaxFactory.getRouter().methods.isStakedLPToken(this.pairAddress).call();
-            }
-            catch (e) {
-                return false;
-            }
-        });
-    }
-    getIsStakedLPToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.isStakedLPToken)
-                this.cache.isStakedLPToken = this.initializeIsStakedLPToken();
-            return this.cache.isStakedLPToken;
-        });
-    }
-    initializeStakedLPToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(yield this.getIsStakedLPToken()))
-                return null;
-            return this.getContractHelper().newStakedLPToken(this.pairAddress);
-        });
-    }
-    getStakedLPToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.stakedLPToken)
-                this.cache.stakedLPToken = this.initializeStakedLPToken();
-            return this.cache.stakedLPToken;
-        });
-    }
-    initializeUniswapV2Pair() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stakedLPToken = yield this.getStakedLPToken();
-            return this.getContractHelper().newUniswapV2Pair(stakedLPToken
-                ? yield (stakedLPToken.methods.underlying().call())
-                : this.pairAddress);
-        });
-    }
-    getUniswapV2Pair() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.uniswapV2Pair)
-                this.cache.uniswapV2Pair = this.initializeUniswapV2Pair();
-            return this.cache.uniswapV2Pair;
-        });
-    }
-    // Reserves
-    initializeReserves() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const uniswapV2Pair = yield this.getUniswapV2Pair();
-            const { reserve0, reserve1 } = yield uniswapV2Pair.methods.getReserves().call();
-            return [
-                yield this.getBorrowableA().normalize(reserve0),
-                yield this.getBorrowableB().normalize(reserve1),
-            ];
-        });
-    }
-    getReserves() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.reserves)
-                this.cache.reserves = this.initializeReserves();
-            return this.cache.reserves;
-        });
-    }
-    // LP Total Supply
-    initializeLPTotalSupply() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const uniswapV2Pair = yield this.getUniswapV2Pair();
-            const totalSupply = yield uniswapV2Pair.methods.totalSupply().call();
-            return this.getCollateral().normalize(totalSupply);
-        });
-    }
-    getLPTotalSupply() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.LPTotalSupply)
-                this.cache.LPTotalSupply = this.initializeLPTotalSupply();
-            return this.cache.LPTotalSupply;
-        });
-    }
-    // Price Denom LP
-    initializePriceDenomLP() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const collateral = yield this.getCollateral().getPoolToken();
-            const { price0, price1 } = yield collateral.methods.getPrices().call();
-            const decimalsA = yield this.getBorrowableA().getDecimals();
-            const decimalsB = yield this.getBorrowableB().getDecimals();
-            let stakedLPExchangeRate = yield this.getStakedLPExchangeRate();
-            return [
-                price0 / 1e18 / 1e18 * Math.pow(10, decimalsA) * stakedLPExchangeRate,
-                price1 / 1e18 / 1e18 * Math.pow(10, decimalsB) * stakedLPExchangeRate
-            ];
-        });
-    }
-    getPriceDenomLP() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.priceDenomLP)
-                this.cache.priceDenomLP = this.initializePriceDenomLP();
-            return this.cache.priceDenomLP;
-        });
-    }
-    getMarketPriceDenomLP() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [reserve0, reserve1] = yield this.getReserves();
-            const totalSupply = yield this.getLPTotalSupply();
-            const [reservesWeight0, reservesWeight1] = yield this.getMarketReservesWeights();
-            return [
-                totalSupply / reserve0 * reservesWeight0,
-                totalSupply / reserve1 * reservesWeight1,
-            ];
-        });
-    }
-    // Market Price
-    getMarketPrice() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [reserve0, reserve1] = yield this.getReserves();
-            const priceInverted = this.impermaxFactory.getOnchain().priceInverted;
-            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory()))
-                return (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(reserve0, reserve1, priceInverted);
-            else
-                return (0, lliquidity_math_1.uniswapV2_getPriceFromReserves)(reserve0, reserve1, priceInverted);
-        });
-    }
-    // Value of reserveA / reserveB
-    initializeTwapReservesValueRatio() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
-                const collateral = yield this.getCollateral().getPoolToken();
-                let { twapReserve0, twapReserve1 } = yield collateral.methods.getTwapReserves().call();
-                const [price0, price1] = yield this.getPriceDenomLP();
-                twapReserve0 = yield this.getBorrowableA().normalize(twapReserve0);
-                twapReserve1 = yield this.getBorrowableB().normalize(twapReserve1);
-                return twapReserve0 * price0 / (twapReserve1 * price1);
-            }
-            else {
-                return 1;
-            }
-        });
-    }
-    getTwapReservesValueRatio() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.twapReservesValueRatio)
-                this.cache.twapReservesValueRatio = this.initializeTwapReservesValueRatio();
-            return this.cache.twapReservesValueRatio;
-        });
-    }
-    getTwapReservesWeights() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const reservesRatio = yield this.getTwapReservesValueRatio();
-            const reservesWeight0 = reservesRatio / (1 + reservesRatio);
-            const reservesWeight1 = 1 / (1 + reservesRatio);
-            return [reservesWeight0, reservesWeight1];
-        });
-    }
-    initializeMarketReservesValueRatio() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
-                const [reserve0, reserve1] = yield this.getReserves();
-                const price = (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(reserve0, reserve1);
-                return reserve0 * price / reserve1;
-            }
-            else {
-                return 1;
-            }
-        });
-    }
-    getMarketReservesValueRatio() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.marketReservesValueRatio)
-                this.cache.marketReservesValueRatio = this.initializeMarketReservesValueRatio();
-            return this.cache.marketReservesValueRatio;
-        });
-    }
-    getMarketReservesWeights() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const reservesRatio = yield this.getMarketReservesValueRatio();
-            const reservesWeight0 = reservesRatio / (1 + reservesRatio);
-            const reservesWeight1 = 1 / (1 + reservesRatio);
-            return [reservesWeight0, reservesWeight1];
-        });
-    }
-    // TWAP Price
-    initializeTWAPPrice() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const collateral = yield this.getCollateral().getPoolToken();
-                const decimalsA = yield this.getBorrowableA().getDecimals();
-                const decimalsB = yield this.getBorrowableB().getDecimals();
-                if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
-                    const { twapReserve0, twapReserve1 } = yield collateral.methods.getTwapReserves().call();
-                    return (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(twapReserve0 / Math.pow(10, decimalsA), twapReserve1 / Math.pow(10, decimalsB));
-                }
-                let price;
-                if (factories_1.SOLIDEX_FACTORIES.includes(this.impermaxFactory.getFactory())) {
-                    price = yield collateral.methods.getTwapPrice112x112().call();
-                }
-                else {
-                    price = (yield this.impermaxFactory.getSimpleUniswapOracle().methods.getResult(this.pairAddress).call()).price;
-                }
-                return price / Math.pow(2, 112) * Math.pow(10, decimalsA) / Math.pow(10, decimalsB);
-            }
-            catch (e) {
-                // Oracle is not initialized yet
-                return 0;
-            }
-        });
-    }
-    getTWAPPrice() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.TWAPPrice)
-                this.cache.TWAPPrice = this.initializeTWAPPrice();
-            return !this.impermaxFactory.getOnchain().priceInverted ? (yield this.cache.TWAPPrice) : 1 / (yield this.cache.TWAPPrice);
-        });
-    }
-    // Exchange rate
-    initializeStakedLPExchangeRate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stakedLPToken = yield this.getStakedLPToken();
-            if (!stakedLPToken)
-                return 1;
-            return (yield stakedLPToken.methods.exchangeRate().call()) / 1e18;
-        });
-    }
-    getStakedLPExchangeRate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.stakedLPExchangeRate)
-                this.cache.stakedLPExchangeRate = this.initializeStakedLPExchangeRate();
-            return this.cache.stakedLPExchangeRate;
-        });
-    }
-    // Pending Reward
-    initializePendingReward() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stakedLPToken = yield this.getStakedLPToken();
-            if (!stakedLPToken)
-                return null;
-            const rewardTokenAddress = yield stakedLPToken.methods.rewardsToken().call();
-            const rewardToken = this.getContractHelper().newERC20(rewardTokenAddress);
-            const decimals = yield rewardToken.methods.decimals().call();
-            let result = {
-                amount: 0,
-                symbol: yield rewardToken.methods.symbol().call(),
-            };
-            try {
-                const pendingReward = yield stakedLPToken.methods.getReward().call();
-                result.amount = pendingReward / Math.pow(10, decimals);
-            }
-            catch (_a) {
-                try {
-                    const stakingRewardsAddress = yield stakedLPToken.methods.stakingRewards().call();
-                    const stakingRewards = this.getContractHelper().newStakingRewards(stakingRewardsAddress);
-                    const earned = yield stakingRewards.methods.earned(stakedLPToken._address).call();
-                    result.amount = earned / Math.pow(10, decimals);
-                }
-                catch (_b) { }
-            }
-            return result;
-        });
-    }
-    getPendingReward() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.pendingReward)
-                this.cache.pendingReward = this.initializePendingReward();
-            return this.cache.pendingReward;
-        });
-    }
-    // Reinvest Bounty Factor
-    initializeReinvestBountyFactor() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stakedLPToken = yield this.getStakedLPToken();
-            if (!stakedLPToken)
-                return 0;
-            return (yield stakedLPToken.methods.REINVEST_BOUNTY().call()) / 1e18;
-        });
-    }
-    getReinvestBountyFactor() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.reinvestBountyFactor)
-                this.cache.reinvestBountyFactor = this.initializeReinvestBountyFactor();
-            return this.cache.reinvestBountyFactor;
-        });
-    }
-    // Reinvest Bounty
-    getReinvestBounty() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pendingReward = yield this.getPendingReward();
-            if (!pendingReward)
-                return 0;
-            const reinvestBountyFactor = yield this.getReinvestBountyFactor();
-            return pendingReward.amount * reinvestBountyFactor;
-        });
-    }
-    // Has Farming
-    hasFarming() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.getBorrowableA().hasFarming()) || (yield this.getBorrowableB().hasFarming());
-        });
-    }
-}
-exports.default = OnchainLendingPool;
+"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 types_1 = require("../../../config/types");
+class OnchainLendingPool {
+    constructor(impermaxFactory, id) {
+        this.cache = {};
+        this.getImpermaxFactory = () => this.impermaxFactory;
+        this.getId = () => this.id;
+        this.getBorrowable = (borrowable) => this.borrowables[borrowable];
+        // Shortcuts
+        this.getBorrowableA = () => this.getBorrowable(types_1.Borrowable.A);
+        this.getBorrowableB = () => this.getBorrowable(types_1.Borrowable.B);
+        this.getCollateral = () => this.collateral;
+        this.getContractHelper = () => this.impermaxFactory.getOnchain().getContractHelper();
+        this.impermaxFactory = impermaxFactory;
+        this.id = id;
+        this.collateral = this.getNewCollateralObject();
+        this.borrowables = {
+            [types_1.Borrowable.A]: this.getNewBorrowableObject(types_1.Borrowable.A),
+            [types_1.Borrowable.B]: this.getNewBorrowableObject(types_1.Borrowable.B),
+        };
+    }
+    cleanCache() {
+        this.cache = {};
+        this.getBorrowableA().cleanCache();
+        this.getBorrowableB().cleanCache();
+        this.getCollateral().cleanCache();
+    }
+    getOffchainLendingPool() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.impermaxFactory.getOnchain().getOffchain().getLendingPool(this.impermaxFactory.getFactory(), this.id);
+        });
+    }
+    initializeLendingPoolAddresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lPool = yield (yield this.impermaxFactory.getFactoryContract()).methods.getLendingPool(this.id).call();
+            return {
+                collateral: lPool.collateral,
+                borrowables: {
+                    [types_1.Borrowable.A]: lPool.borrowable0,
+                    [types_1.Borrowable.B]: lPool.borrowable1,
+                }
+            };
+        });
+    }
+    getLendingPoolAddresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.lendingPoolAddresses)
+                this.cache.lendingPoolAddresses = this.initializeLendingPoolAddresses();
+            return this.cache.lendingPoolAddresses;
+        });
+    }
+    getCollateralAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getLendingPoolAddresses()).collateral;
+        });
+    }
+    ;
+    getBorrowableAddress(borrowable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getLendingPoolAddresses()).borrowables[borrowable];
+        });
+    }
+    ;
+    // Has Farming
+    hasFarming() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getBorrowableA().hasFarming()) || (yield this.getBorrowableB().hasFarming());
+        });
+    }
+}
+exports.default = OnchainLendingPool;

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

@@ -0,0 +1,76 @@
+import { Address, Borrowable } from '../../../config/types';
+import { Contract, PendingRewardUI } from '../../onchainTypes';
+import OnchainLendingPool from "./onchainLendingPool";
+import OnchainCollateralV2 from "./onchainCollateralV2";
+import OnchainBorrowableV2 from "./onchainBorrowableV2";
+import OnchainImpermaxFactoryV2 from "../onchainImpermaxFactoryV2";
+import { OnchainAccountLendingPoolV2 } from "../../account/lendingPool";
+import OnchainAccount from "../../account";
+import OnchainInteractionsLendingPoolV2 from "../../interactions/lendingPool/onchainInteractionsLendingPoolV2";
+import OnchainInteractions from "../../interactions";
+export default class OnchainLendingPoolV2 extends OnchainLendingPool {
+    protected readonly impermaxFactory: OnchainImpermaxFactoryV2;
+    protected readonly collateral: OnchainCollateralV2;
+    protected readonly borrowables: {
+        [Borrowable.A]: OnchainBorrowableV2;
+        [Borrowable.B]: OnchainBorrowableV2;
+    };
+    protected cache: {
+        lendingPoolAddresses?: Promise<{
+            collateral: Address;
+            borrowables: {
+                [key in Borrowable]: Address;
+            };
+        }>;
+        isStakedLPToken?: Promise<boolean>;
+        uniswapV2Pair?: Promise<Contract>;
+        stakedLPToken?: Promise<Contract | null>;
+        reserves?: Promise<[number, number]>;
+        LPTotalSupply?: Promise<number>;
+        marketPrice?: Promise<number>;
+        priceDenomLP?: Promise<[number, number]>;
+        twapReservesValueRatio?: Promise<number>;
+        marketReservesValueRatio?: Promise<number>;
+        TWAPPrice?: Promise<number>;
+        pendingReward?: Promise<PendingRewardUI | null>;
+        reinvestBountyFactor?: Promise<number>;
+        stakedLPExchangeRate?: Promise<number>;
+    };
+    protected getNewCollateralObject(): OnchainCollateralV2;
+    protected getNewBorrowableObject(borrowable: Borrowable): OnchainBorrowableV2;
+    getNewAccountLendingPoolObject(account: OnchainAccount): OnchainAccountLendingPoolV2;
+    getNewInteractionLendingPoolObject(interactions: OnchainInteractions): OnchainInteractionsLendingPoolV2;
+    getBorrowable: (borrowable: Borrowable) => OnchainBorrowableV2;
+    getBorrowableA: () => OnchainBorrowableV2;
+    getBorrowableB: () => OnchainBorrowableV2;
+    getCollateral: () => OnchainCollateralV2;
+    private initializeIsStakedLPToken;
+    getIsStakedLPToken(): Promise<boolean>;
+    private initializeStakedLPToken;
+    getStakedLPToken(): Promise<any>;
+    private initializeUniswapV2Pair;
+    getUniswapV2Pair(): Promise<any>;
+    private initializeReserves;
+    getReserves(): Promise<[number, number]>;
+    private initializeLPTotalSupply;
+    getLPTotalSupply(): Promise<number>;
+    private initializePriceDenomLP;
+    getPriceDenomLP(): Promise<[number, number]>;
+    getMarketPriceDenomLP(): Promise<[number, number]>;
+    getMarketPrice(): Promise<number>;
+    private initializeTwapReservesValueRatio;
+    getTwapReservesValueRatio(): Promise<number>;
+    getTwapReservesWeights(): Promise<[number, number]>;
+    private initializeMarketReservesValueRatio;
+    getMarketReservesValueRatio(): Promise<number>;
+    getMarketReservesWeights(): Promise<[number, number]>;
+    private initializeTWAPPrice;
+    getTWAPPrice(): Promise<number>;
+    private initializeStakedLPExchangeRate;
+    getStakedLPExchangeRate(): Promise<number>;
+    private initializePendingReward;
+    getPendingReward(): Promise<PendingRewardUI | null>;
+    private initializeReinvestBountyFactor;
+    getReinvestBountyFactor(): Promise<number>;
+    getReinvestBounty(): Promise<number>;
+}