impermax-sdk 1.0.1 → 1.0.2

package/lib/esm/impermax-router/InteractionsPoolToken.d.ts

@@ -0,0 +1,23 @@
+import { ethers, BigNumber } from "ethers";
+import AccountPoolToken from "./AccountPoolToken";
+import InteractionsLendingPool from "./InteractionsLendingPool";
+import { ApprovalType, PermitData } from "./interfaces";
+import { PoolTokenType } from '../config/types';
+export default class InteractionsPoolToken {
+    interactionsLendingPool: InteractionsLendingPool;
+    accountPoolToken: AccountPoolToken;
+    constructor(interactionsLendingPool: InteractionsLendingPool, poolTokenType: PoolTokenType);
+    getImpermaxRouter: () => import(".").default;
+    getPoolToken: () => import("./PoolToken").default;
+    getRouterContract: () => any;
+    send: (method: any, onTransactionHash: Function, value?: BigNumber) => Promise<any>;
+    isWETH(): Promise<boolean>;
+    isCollateral(): boolean;
+    getAllowance(approvalType: ApprovalType): Promise<ethers.BigNumber>;
+    approve(approvalType: ApprovalType, amount: BigNumber, onTransactionHash: Function): Promise<any>;
+    getPermitData(approvalType: ApprovalType, amount: BigNumber, deadlineArg: BigNumber | null, callBack: (permitData: PermitData) => void): Promise<void>;
+    deposit(amount: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+    withdraw(tokens: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+    borrow(amount: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+    repay(amount: BigNumber, onTransactionHash: Function): Promise<any>;
+}

package/lib/esm/impermax-router/InteractionsPoolToken.js

@@ -0,0 +1,194 @@
+"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 ethers_1 = require("ethers");
+const interfaces_1 = require("./interfaces");
+const types_1 = require("../config/types");
+const weths_1 = require("../config/contracts/weths");
+const general_1 = require("../config/general");
+const MAX_UINT256 = ethers_1.ethers.constants.MaxUint256;
+const EIP712DOMAIN = [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" },
+];
+const PERMIT = [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+];
+const TYPES = {
+    EIP712Domain: EIP712DOMAIN,
+    Permit: PERMIT,
+    BorrowPermit: PERMIT,
+};
+class InteractionsPoolToken {
+    constructor(interactionsLendingPool, poolTokenType) {
+        // Shortcuts
+        this.getImpermaxRouter = () => this.interactionsLendingPool.interactions.account.router;
+        this.getPoolToken = () => this.accountPoolToken.poolToken;
+        this.getRouterContract = () => this.interactionsLendingPool.accountLendingPool.lendingPool.factory.getRouter();
+        this.send = (method, onTransactionHash, value) => this.interactionsLendingPool.interactions.send(method, onTransactionHash, value);
+        this.interactionsLendingPool = interactionsLendingPool;
+        this.accountPoolToken = interactionsLendingPool.accountLendingPool.accountPoolTokens[poolTokenType];
+    }
+    isWETH() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.getPoolToken().getToken();
+            return token._address.toLowerCase() == weths_1.WETH[this.getImpermaxRouter().network].toLowerCase();
+        });
+    }
+    isCollateral() {
+        return this.getPoolToken().poolTokenType == types_1.PoolTokenType.Collateral;
+    }
+    getAllowance(approvalType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolToken = yield this.getPoolToken().getPoolToken();
+            const token = yield this.getPoolToken().getToken();
+            if ((yield this.isWETH()) && approvalType == interfaces_1.ApprovalType.UNDERLYING)
+                return MAX_UINT256;
+            const { owner, spender } = this.interactionsLendingPool.getOwnerSpender();
+            const allowance = (approvalType == interfaces_1.ApprovalType.POOL_TOKEN) ? yield poolToken.methods.allowance(owner, spender).call() :
+                (approvalType == interfaces_1.ApprovalType.UNDERLYING) ? yield token.methods.allowance(owner, spender).call() :
+                    (approvalType == interfaces_1.ApprovalType.BORROW) ? yield poolToken.methods.borrowAllowance(owner, spender).call() : 0;
+            return ethers_1.BigNumber.from(allowance);
+        });
+    }
+    approve(approvalType, amount, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { spender } = this.interactionsLendingPool.getOwnerSpender();
+            const poolToken = yield this.getPoolToken().getPoolToken();
+            const token = yield this.getPoolToken().getToken();
+            let method;
+            if (approvalType == interfaces_1.ApprovalType.POOL_TOKEN)
+                method = poolToken.methods.approve(spender, amount);
+            if (approvalType == interfaces_1.ApprovalType.UNDERLYING)
+                method = token.methods.approve(spender, amount);
+            if (approvalType == interfaces_1.ApprovalType.BORROW)
+                method = poolToken.methods.borrowApprove(spender, amount);
+            return this.send(method, onTransactionHash);
+        });
+    }
+    getPermitData(approvalType, amount, deadlineArg, callBack) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (approvalType === interfaces_1.ApprovalType.UNDERLYING && this.getPoolToken().poolTokenType != types_1.PoolTokenType.Collateral)
+                return callBack(null);
+            const { owner, spender } = this.interactionsLendingPool.getOwnerSpender();
+            const poolToken = yield this.getPoolToken().getPoolToken();
+            const token = yield this.getPoolToken().getToken();
+            const contract = approvalType == interfaces_1.ApprovalType.UNDERLYING ? token : poolToken;
+            const nonce = yield contract.methods.nonces(owner).call();
+            const name = yield contract.methods.name().call();
+            const deadline = deadlineArg ? deadlineArg : general_1.DEADLINE;
+            const data = JSON.stringify({
+                types: TYPES,
+                domain: {
+                    name: name,
+                    version: "1",
+                    chainId: this.getImpermaxRouter().chainId,
+                    verifyingContract: contract._address,
+                },
+                primaryType: approvalType == interfaces_1.ApprovalType.BORROW ? "BorrowPermit" : "Permit",
+                message: {
+                    owner: owner,
+                    spender: spender,
+                    value: amount.toString(),
+                    nonce: ethers_1.BigNumber.from(nonce).toHexString(),
+                    deadline: deadline.toNumber(),
+                }
+            });
+            this.getImpermaxRouter().web3.currentProvider.send({
+                method: "eth_signTypedData_v4",
+                params: [owner, data],
+                from: owner
+            }, (err, data) => {
+                if (err) {
+                    console.error(err);
+                    return callBack(null);
+                }
+                const signature = data.result.substring(2);
+                const r = "0x" + signature.substring(0, 64);
+                const s = "0x" + signature.substring(64, 128);
+                let v = parseInt(signature.substring(128, 130), 16);
+                if (v == 0 || v == 1)
+                    v = v + 27;
+                //console.log(v, r, s);
+                const permitData = ethers_1.ethers.utils.defaultAbiCoder.encode(['bool', 'uint8', 'bytes32', 'bytes32'], [false, v, r, s]);
+                callBack({ permitData, deadline, amount });
+            });
+        });
+    }
+    deposit(amount, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const router = this.getRouterContract();
+            const poolToken = yield this.getPoolToken().getPoolToken();
+            const data = permitData ? permitData.permitData : '0x';
+            const deadline = permitData ? permitData.deadline : general_1.DEADLINE;
+            const account = this.accountPoolToken.getAccount();
+            if (yield this.isWETH()) {
+                return this.send(router.methods.mintETH(poolToken._address, account, deadline), onTransactionHash, amount);
+            }
+            else if (this.isCollateral()) {
+                return this.send(router.methods.mintCollateral(poolToken._address, amount, account, deadline, data), onTransactionHash);
+            }
+            else {
+                return this.send(router.methods.mint(poolToken._address, amount, account, deadline), onTransactionHash);
+            }
+        });
+    }
+    withdraw(tokens, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const router = this.getRouterContract();
+            const poolToken = yield this.getPoolToken().getPoolToken();
+            const data = permitData ? permitData.permitData : '0x';
+            const deadline = permitData ? permitData.deadline : general_1.DEADLINE;
+            const account = this.accountPoolToken.getAccount();
+            if (yield this.isWETH()) {
+                return this.send(router.methods.redeemETH(poolToken._address, tokens, account, deadline, data), onTransactionHash);
+            }
+            else {
+                return this.send(router.methods.redeem(poolToken._address, tokens, account, deadline, data), onTransactionHash);
+            }
+        });
+    }
+    borrow(amount, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const router = this.getRouterContract();
+            const borrowable = yield this.getPoolToken().getPoolToken();
+            const data = permitData ? permitData.permitData : '0x';
+            const deadline = permitData ? permitData.deadline : general_1.DEADLINE;
+            const account = this.accountPoolToken.getAccount();
+            if (yield this.isWETH()) {
+                return this.send(router.methods.borrowETH(borrowable._address, amount, account, deadline, data), onTransactionHash);
+            }
+            else {
+                return this.send(router.methods.borrow(borrowable._address, amount, account, deadline, data), onTransactionHash);
+            }
+        });
+    }
+    repay(amount, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const router = this.getRouterContract();
+            const borrowable = yield this.getPoolToken().getPoolToken();
+            const account = this.accountPoolToken.getAccount();
+            if (yield this.isWETH()) {
+                return this.send(router.methods.repayETH(borrowable._address, account, general_1.DEADLINE), onTransactionHash, amount);
+            }
+            else {
+                return this.send(router.methods.repay(borrowable._address, amount, account, general_1.DEADLINE), onTransactionHash);
+            }
+        });
+    }
+}
+exports.default = InteractionsPoolToken;

package/lib/esm/impermax-router/LendingPool.d.ts

@@ -0,0 +1,69 @@
+import { PendingRewardUI } from "./interfaces";
+import PoolToken from "./PoolToken";
+import ImpermaxFactory from "./ImpermaxFactory";
+import { Contract } from "ethers";
+import Collateral from "./Collateral";
+import Borrowable from "./Borrowable";
+import { Address, PoolTokenType } from '../config/types';
+export default class LendingPool {
+    factory: ImpermaxFactory;
+    pairAddress: Address;
+    poolTokens: {
+        [PoolTokenType.Collateral]: Collateral;
+        [PoolTokenType.BorrowableA]: Borrowable;
+        [PoolTokenType.BorrowableB]: Borrowable;
+    };
+    cache: {
+        poolTokenAddresses?: Promise<{
+            [key in PoolTokenType]: Address;
+        }>;
+        isStakedLPToken?: Promise<boolean>;
+        uniswapV2Pair?: Promise<Contract>;
+        stakedLPToken?: Promise<Contract>;
+        reserves?: Promise<[number, number]>;
+        LPTotalSupply?: Promise<number>;
+        marketPrice?: Promise<number>;
+        priceDenomLP?: Promise<[number, number]>;
+        TWAPPrice?: Promise<number>;
+        pendingReward?: Promise<PendingRewardUI>;
+        reinvestBountyFactor?: Promise<number>;
+        stakedLPExchangeRate?: Promise<number>;
+    };
+    constructor(factory: ImpermaxFactory, pairAddress: Address);
+    cleanCache(): void;
+    pta: () => Borrowable;
+    ptb: () => Borrowable;
+    ptc: () => Collateral;
+    getPoolToken(poolTokenType: PoolTokenType): PoolToken;
+    getSubgraphLendingPool(): Promise<import("../subgraph/LendingPool").default>;
+    private initializePoolTokenAddresses;
+    getPoolTokenAddresses(): Promise<{
+        collateral: string;
+        borrowable0: string;
+        borrowable1: string;
+    }>;
+    private initializeIsStakedLPToken;
+    getIsStakedLPToken(): Promise<boolean>;
+    private initializeStakedLPToken;
+    getStakedLPToken(): Promise<Contract>;
+    private initializeUniswapV2Pair;
+    getUniswapV2Pair(): Promise<Contract>;
+    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 initializeTWAPPrice;
+    getTWAPPrice(): Promise<number>;
+    private initializeStakedLPExchangeRate;
+    getStakedLPExchangeRate(): Promise<number>;
+    private initializePendingReward;
+    getPendingReward(): Promise<PendingRewardUI>;
+    private initializeReinvestBountyFactor;
+    getReinvestBountyFactor(): Promise<number>;
+    getReinvestBounty(): Promise<number>;
+    hasFarming(): Promise<boolean>;
+}

package/lib/esm/impermax-router/LendingPool.js

@@ -0,0 +1,291 @@
+"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 Collateral_1 = __importDefault(require("./Collateral"));
+const Borrowable_1 = __importDefault(require("./Borrowable"));
+const types_1 = require("../config/types");
+const factories_1 = require("../config/factories");
+class LendingPool {
+    constructor(factory, pairAddress) {
+        this.cache = {};
+        // Shortcuts
+        this.pta = () => this.poolTokens[types_1.PoolTokenType.BorrowableA];
+        this.ptb = () => this.poolTokens[types_1.PoolTokenType.BorrowableB];
+        this.ptc = () => this.poolTokens[types_1.PoolTokenType.Collateral];
+        this.factory = factory;
+        this.pairAddress = pairAddress;
+        this.poolTokens = {
+            [types_1.PoolTokenType.Collateral]: new Collateral_1.default(this, types_1.PoolTokenType.Collateral),
+            [types_1.PoolTokenType.BorrowableA]: new Borrowable_1.default(this, types_1.PoolTokenType.BorrowableA),
+            [types_1.PoolTokenType.BorrowableB]: new Borrowable_1.default(this, types_1.PoolTokenType.BorrowableB),
+        };
+    }
+    cleanCache() {
+        this.cache = {};
+        this.pta().cleanCache();
+        this.ptb().cleanCache();
+        this.ptc().cleanCache();
+    }
+    getPoolToken(poolTokenType) {
+        return this.poolTokens[poolTokenType];
+    }
+    getSubgraphLendingPool() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.factory.router.subgraph.getLendingPool(this.factory.factory, this.pairAddress);
+        });
+    }
+    initializePoolTokenAddresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lPool = yield this.factory.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.factory.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.factory.router.contractsHelper.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* () {
+            return this.factory.router.contractsHelper.newUniswapV2Pair((yield this.getIsStakedLPToken())
+                ? yield (yield this.getStakedLPToken()).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.pta().normalize(reserve0),
+                yield this.ptb().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.ptc().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.ptc().getPoolToken();
+            const { price0, price1 } = yield collateral.methods.getPrices().call();
+            const decimalsA = yield this.pta().getDecimals();
+            const decimalsB = yield this.ptb().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();
+            return [
+                totalSupply / reserve0 / 2,
+                totalSupply / reserve1 / 2,
+            ];
+        });
+    }
+    // Market Price
+    getMarketPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [reserve0, reserve1] = yield this.getReserves();
+            return this.factory.router.priceInverted ? 1 * reserve0 / reserve1 : 1 * reserve1 / reserve0;
+        });
+    }
+    // TWAP Price
+    initializeTWAPPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let price;
+                if (factories_1.SOLIDEX_FACTORIES.includes(this.factory.factory)) {
+                    const collateral = yield this.ptc().getPoolToken();
+                    price = yield collateral.methods.getTwapPrice112x112().call();
+                }
+                else {
+                    price = (yield this.factory.getSimpleUniswapOracle().methods.getResult(this.pairAddress).call()).price;
+                }
+                const decimalsA = yield this.pta().getDecimals();
+                const decimalsB = yield this.ptb().getDecimals();
+                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.factory.router.priceInverted ? (yield this.cache.TWAPPrice) : 1 / (yield this.cache.TWAPPrice);
+        });
+    }
+    // Exchange rate
+    initializeStakedLPExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.getIsStakedLPToken()))
+                return 1;
+            const stakedLPToken = yield this.getStakedLPToken();
+            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();
+            const rewardTokenAddress = yield stakedLPToken.methods.rewardsToken().call();
+            const rewardToken = this.factory.router.contractsHelper.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.factory.router.contractsHelper.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* () {
+            if (!(yield this.getIsStakedLPToken()))
+                return 0;
+            const stakedLPToken = yield this.getStakedLPToken();
+            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();
+            const reinvestBountyFactor = yield this.getReinvestBountyFactor();
+            return pendingReward.amount * reinvestBountyFactor;
+        });
+    }
+    // Has Farming
+    hasFarming() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.pta().hasFarming()) || (yield this.ptb().hasFarming());
+        });
+    }
+}
+exports.default = LendingPool;

package/lib/esm/impermax-router/PoolToken.d.ts

@@ -0,0 +1,36 @@
+import { BigNumber } from "ethers";
+import { Contract } from "./interfaces";
+import LendingPool from "./LendingPool";
+import { Address, PoolTokenType } from '../config/types';
+export default abstract class PoolToken {
+    lendingPool: LendingPool;
+    poolTokenType: PoolTokenType;
+    cache: {
+        token?: Promise<Contract>;
+        poolToken?: Promise<Contract>;
+        exchangeRate?: Promise<number>;
+        totalBalance?: Promise<number>;
+    };
+    constructor(lendingPool: LendingPool, poolTokenType: PoolTokenType);
+    cleanCache(): void;
+    getContractHelper: () => import("./ContractsHelper").default;
+    getSubgraphPoolToken(): Promise<import("../subgraph/PoolToken").default>;
+    protected getPoolTokenAddressFromLendingPool(): Promise<string>;
+    abstract initializePoolToken(): Promise<Contract>;
+    getPoolToken(): Promise<any>;
+    getPoolTokenAddress(): Promise<Address>;
+    abstract initializeToken(): Promise<Contract>;
+    getToken(): Promise<any>;
+    getTokenAddress(): Promise<any>;
+    getDecimals(): Promise<number>;
+    normalize(amount: number): Promise<number>;
+    toBigNumber(amount: number): Promise<BigNumber>;
+    toNumber(amount: BigNumber): Promise<number>;
+    toTokens(amount: number): Promise<BigNumber>;
+    fromTokens(amount: BigNumber): Promise<number>;
+    private initializeTotalBalance;
+    getTotalBalance(): Promise<number>;
+    getTotalBalanceUSD(): Promise<number>;
+    protected initializeExchangeRate(): Promise<number>;
+    getExchangeRate(): Promise<number>;
+}