impermax-sdk 1.0.1 → 1.0.2

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

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

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

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

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

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

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

@@ -0,0 +1,45 @@
+"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() {
+        super(...arguments);
+        this.collateralCache = {};
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.collateralCache = {};
+    }
+    initializePoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.lendingPool.factory.router.contractsHelper.newCollateral(yield this.getPoolTokenAddressFromLendingPool());
+        });
+    }
+    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/esm/impermax-router/ContractsHelper.d.ts

@@ -0,0 +1,28 @@
+import { Contract } from "./interfaces";
+import ImpermaxRouter from "./index";
+import { Address } from '../config/types';
+export default class ContractsHelper {
+    router: ImpermaxRouter;
+    impermaxChef: Contract;
+    merkleDistributorIbex: Contract;
+    merkleDistributorIbex2: Contract;
+    merkleDistributorEth: Contract;
+    claimAggregator: Contract;
+    constructor(router: ImpermaxRouter);
+    newContract: (abi: any, address: Address) => any;
+    newRouter: (address: Address) => any;
+    newFactory: (address: Address) => any;
+    newSimpleUniswapOracle: (address: Address) => any;
+    newUniswapV2Pair: (address: Address) => any;
+    newUniswapV2Factory: (address: Address) => any;
+    newERC20: (address: Address) => any;
+    newCollateral: (address: Address) => any;
+    newBorrowable: (address: Address) => any;
+    newStakedLPToken: (address: Address) => any;
+    newMerkleDistributor: (address: Address) => any;
+    newFarmingPool: (address: Address) => any;
+    newClaimAggregator: (address: Address) => any;
+    newClaimable: (address: Address) => any;
+    newStakingRewards: (address: Address) => any;
+    newImpermaxChef: (address: Address) => any;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const IERC20_json_1 = __importDefault(require("../abis/contracts/IERC20.json"));
+const IUniswapV2Pair_json_1 = __importDefault(require("../abis/contracts/IUniswapV2Pair.json"));
+const IUniswapV2Factory_json_1 = __importDefault(require("../abis/contracts/IUniswapV2Factory.json"));
+const IRouter02_json_1 = __importDefault(require("../abis/contracts/IRouter02.json"));
+const IBorrowable_json_1 = __importDefault(require("../abis/contracts/IBorrowable.json"));
+const ICollateral_json_1 = __importDefault(require("../abis/contracts/ICollateral.json"));
+const IStakedLPToken_json_1 = __importDefault(require("../abis/contracts/IStakedLPToken.json"));
+const IFactory_json_1 = __importDefault(require("../abis/contracts/IFactory.json"));
+const ISimpleUniswapOracle_json_1 = __importDefault(require("../abis/contracts/ISimpleUniswapOracle.json"));
+const IMerkleDistributor_json_1 = __importDefault(require("../abis/contracts/IMerkleDistributor.json"));
+const IFarmingPool_json_1 = __importDefault(require("../abis/contracts/IFarmingPool.json"));
+const ClaimAggregator_json_1 = __importDefault(require("../abis/contracts/ClaimAggregator.json"));
+const IClaimable_json_1 = __importDefault(require("../abis/contracts/IClaimable.json"));
+const IStakingRewards_json_1 = __importDefault(require("../abis/contracts/IStakingRewards.json"));
+const ImpermaxChef_json_1 = __importDefault(require("../abis/contracts/ImpermaxChef.json"));
+const impermax_chef_1 = require("../config/contracts/impermax-chef");
+const claim_aggregators_1 = require("../config/contracts/claim-aggregators");
+const merkle_distributors_1 = require("../config/contracts/merkle-distributors");
+class ContractsHelper {
+    constructor(router) {
+        this.newContract = (abi, address) => new this.router.web3.eth.Contract(abi, address);
+        this.newRouter = (address) => this.newContract(IRouter02_json_1.default.abi, address);
+        this.newFactory = (address) => this.newContract(IFactory_json_1.default.abi, address);
+        this.newSimpleUniswapOracle = (address) => this.newContract(ISimpleUniswapOracle_json_1.default.abi, address);
+        this.newUniswapV2Pair = (address) => this.newContract(IUniswapV2Pair_json_1.default.abi, address);
+        this.newUniswapV2Factory = (address) => this.newContract(IUniswapV2Factory_json_1.default.abi, address);
+        this.newERC20 = (address) => this.newContract(IERC20_json_1.default.abi, address);
+        this.newCollateral = (address) => this.newContract(ICollateral_json_1.default.abi, address);
+        this.newBorrowable = (address) => this.newContract(IBorrowable_json_1.default.abi, address);
+        this.newStakedLPToken = (address) => this.newContract(IStakedLPToken_json_1.default.abi, address);
+        this.newMerkleDistributor = (address) => this.newContract(IMerkleDistributor_json_1.default.abi, address);
+        this.newFarmingPool = (address) => this.newContract(IFarmingPool_json_1.default.abi, address);
+        this.newClaimAggregator = (address) => this.newContract(ClaimAggregator_json_1.default.abi, address);
+        this.newClaimable = (address) => this.newContract(IClaimable_json_1.default.abi, address);
+        this.newStakingRewards = (address) => this.newContract(IStakingRewards_json_1.default.abi, address);
+        this.newImpermaxChef = (address) => this.newContract(ImpermaxChef_json_1.default.abi, address);
+        this.router = router;
+        this.impermaxChef = this.newImpermaxChef(impermax_chef_1.IMPERMAX_CHEF[this.router.network]);
+        this.merkleDistributorIbex = this.newMerkleDistributor(merkle_distributors_1.MERKLE_DISTRIBUTOR_IBEX[this.router.network]);
+        this.merkleDistributorIbex2 = this.newMerkleDistributor(merkle_distributors_1.MERKLE_DISTRIBUTOR_IBEX_2[this.router.network]);
+        this.merkleDistributorEth = this.newMerkleDistributor(merkle_distributors_1.MERKLE_DISTRIBUTOR_ETH[this.router.network]);
+        this.claimAggregator = this.newClaimAggregator(claim_aggregators_1.CLAIM_AGGREGATOR[this.router.network]);
+    }
+}
+exports.default = ContractsHelper;

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

@@ -0,0 +1,15 @@
+import ImpermaxRouter from "./index";
+import LendingPool from "./LendingPool";
+import { Address, Factory } from '../config/types';
+export default class ImpermaxFactory {
+    router: ImpermaxRouter;
+    factory: Factory;
+    lendingPools: {
+        [key in Address]: LendingPool;
+    };
+    constructor(router: ImpermaxRouter, factory: Factory);
+    cleanCache(): void;
+    getSimpleUniswapOracle(): any;
+    getRouter(): any;
+    getLendingPool(uniswapV2PairAddress: Address): LendingPool;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LendingPool_1 = __importDefault(require("./LendingPool"));
+const simple_uniswap_oracles_1 = require("../config/contracts/simple-uniswap-oracles");
+const routers_1 = require("../config/contracts/routers");
+class ImpermaxFactory {
+    constructor(router, factory) {
+        this.router = router;
+        this.factory = factory;
+        this.lendingPools = {};
+    }
+    cleanCache() {
+        for (const pairAddress of Object.keys(this.lendingPools)) {
+            this.lendingPools[pairAddress].cleanCache();
+        }
+    }
+    getSimpleUniswapOracle() {
+        const address = simple_uniswap_oracles_1.SIMPLE_UNISWAP_ORACLE[this.router.network][this.factory];
+        if (!address) {
+            console.error("SimpleUniswapOracle address not found");
+            return null;
+        }
+        return this.router.contractsHelper.newSimpleUniswapOracle(address);
+    }
+    getRouter() {
+        const address = routers_1.ROUTER[this.router.network][this.factory];
+        if (!address) {
+            console.error("Router address not found");
+            return null;
+        }
+        return this.router.contractsHelper.newRouter(address);
+    }
+    getLendingPool(uniswapV2PairAddress) {
+        if (!this.lendingPools[uniswapV2PairAddress])
+            this.lendingPools[uniswapV2PairAddress] = new LendingPool_1.default(this, uniswapV2PairAddress);
+        return this.lendingPools[uniswapV2PairAddress];
+    }
+}
+exports.default = ImpermaxFactory;

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

@@ -0,0 +1,16 @@
+import { BigNumber } from "ethers";
+import Account from "./Account";
+import InteractionsLendingPool from "./InteractionsLendingPool";
+import { AirdropData, Contract } from "./interfaces";
+import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+export default class Interactions {
+    account: Account;
+    interactionsLLPs: LendingPoolIndex<Promise<InteractionsLendingPool>>;
+    constructor(account: Account);
+    private initializeInteractionsLendingPool;
+    getInteractionsLendingPool(factory: Factory, pair: Address): Promise<InteractionsLendingPool>;
+    send(method: any, onTransactionHash: Function, value?: BigNumber): Promise<any>;
+    claimAirdrop(airdropData: AirdropData, merkleDistributor: Contract, onTransactionHash: Function): Promise<any>;
+    claims(pairAddresses: FactoryIndex<Address[]>, onTransactionHash: Function): Promise<any>;
+    claimDistributor(claimableAddress: Address, onTransactionHash: Function): Promise<any>;
+}

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

@@ -0,0 +1,105 @@
+"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 ethers_1 = require("ethers");
+const InteractionsLendingPool_1 = __importDefault(require("./InteractionsLendingPool"));
+const types_1 = require("../config/types");
+const ZERO = ethers_1.BigNumber.from(0);
+class Interactions {
+    constructor(account) {
+        this.account = account;
+        this.interactionsLLPs = {};
+    }
+    initializeInteractionsLendingPool(factory, pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.account.getAccountLendingPool(factory, pair);
+            return new InteractionsLendingPool_1.default(this, lendingPool);
+        });
+    }
+    getInteractionsLendingPool(factory, pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.interactionsLLPs[factory])
+                this.interactionsLLPs[factory] = {};
+            if (!this.interactionsLLPs[factory][pair])
+                this.interactionsLLPs[factory][pair] = this.initializeInteractionsLendingPool(factory, pair);
+            return this.interactionsLLPs[factory][pair];
+        });
+    }
+    send(method, onTransactionHash, value = ZERO) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield method.call({ from: this.account.account, value });
+                return method.send({ from: this.account.account, value }).on('transactionHash', onTransactionHash);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
+    claimAirdrop(airdropData, merkleDistributor, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.send(merkleDistributor.methods.claim(airdropData.index, this.account.account, airdropData.amount, airdropData.proof), onTransactionHash);
+        });
+    }
+    claims(pairAddresses, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requests = [];
+            for (const factory of Object.keys(pairAddresses)) {
+                for (const pairAddress of pairAddresses[factory]) {
+                    for (const poolToken of [types_1.PoolTokenType.BorrowableA, types_1.PoolTokenType.BorrowableB]) {
+                        requests.push((() => __awaiter(this, void 0, void 0, function* () {
+                            const accountBorrowable = (yield this.account.getAccountLendingPool(factory, pairAddress)).accountPoolTokens[poolToken];
+                            const borrowable = accountBorrowable.poolToken;
+                            const pendingReward = (yield accountBorrowable.getAvailableIMXReward()) + (yield accountBorrowable.getAvailableRewarderReward());
+                            return {
+                                hasPendingReward: pendingReward > 0,
+                                hasImpermaxChef: yield borrowable.hasImpermaxChef(),
+                                farmingPool: yield borrowable.getFarmingPool(),
+                                borrowableAddress: yield borrowable.getPoolTokenAddress(),
+                            };
+                        }))());
+                    }
+                }
+            }
+            const data = yield Promise.all(requests);
+            const toClaimThroughChef = [];
+            const toClaimThroughAggregator = [];
+            for (const borrowable of data) {
+                if (!borrowable.hasPendingReward)
+                    continue;
+                if (borrowable.hasImpermaxChef) {
+                    toClaimThroughChef.push(borrowable.borrowableAddress);
+                }
+                else {
+                    toClaimThroughAggregator.push(borrowable.farmingPool._address);
+                }
+            }
+            if (toClaimThroughAggregator.length > 0) {
+                const claimAggregator = this.account.router.contractsHelper.claimAggregator;
+                return this.send(claimAggregator.methods.claims(this.account.account, toClaimThroughAggregator), onTransactionHash);
+            }
+            else if (toClaimThroughChef.length > 0) {
+                const impermaxChef = this.account.router.contractsHelper.impermaxChef;
+                return this.send(impermaxChef.methods.massHarvest(toClaimThroughChef, this.account.account), onTransactionHash);
+            }
+        });
+    }
+    claimDistributor(claimableAddress, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const claimable = this.account.router.contractsHelper.newClaimable(claimableAddress);
+            return this.send(claimable.methods.claim(), onTransactionHash);
+        });
+    }
+}
+exports.default = Interactions;

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

@@ -0,0 +1,43 @@
+import Interactions from "./Interactions";
+import AccountLendingPool from "./AccountLendingPool";
+import InteractionsPoolToken from "./InteractionsPoolToken";
+import { BigNumber } from "ethers";
+import { PoolTokenType } from '../config/types';
+import { PermitData } from './interfaces';
+export default class InteractionsLendingPool {
+    interactions: Interactions;
+    accountLendingPool: AccountLendingPool;
+    interactionsPoolToken: {
+        [PoolTokenType.Collateral]: InteractionsPoolToken;
+        [PoolTokenType.BorrowableA]: InteractionsPoolToken;
+        [PoolTokenType.BorrowableB]: InteractionsPoolToken;
+    };
+    constructor(interactions: Interactions, accountLendingPool: AccountLendingPool);
+    getRouterLendingPool: () => import("./LendingPool").default;
+    getRouterContract: () => any;
+    getAccount: () => string;
+    send: (method: any, onTransactionHash: Function) => Promise<any>;
+    getOwnerSpender(): {
+        owner: string;
+        spender: any;
+    };
+    getLeverageAmounts(leverage: number, slippage: number): Promise<{
+        bAmountA: number;
+        bAmountB: number;
+        cAmount: number;
+        bAmountAMin: number;
+        bAmountBMin: number;
+        cAmountMin: number;
+    }>;
+    leverage(amountA: BigNumber, amountB: BigNumber, amountAMin: BigNumber, amountBMin: BigNumber, permitDataA: PermitData, permitDataB: PermitData, onTransactionHash: Function): Promise<any>;
+    getDeleverageAmounts(changeCollateralAmount: number, slippage: number): Promise<{
+        bAmountA: number;
+        bAmountB: number;
+        cAmount: number;
+        bAmountAMin: number;
+        bAmountBMin: number;
+    }>;
+    deleverage(tokens: BigNumber, amountAMin: BigNumber, amountBMin: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+    trackBorrows(onTransactionHash: Function): Promise<any>;
+    reinvest(onTransactionHash: Function): Promise<any>;
+}

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

@@ -0,0 +1,124 @@
+"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 InteractionsPoolToken_1 = __importDefault(require("./InteractionsPoolToken"));
+const utils_1 = require("../utils");
+const types_1 = require("../config/types");
+const general_1 = require("../config/general");
+class InteractionsLendingPool {
+    constructor(interactions, accountLendingPool) {
+        this.getRouterLendingPool = () => this.accountLendingPool.lendingPool;
+        this.getRouterContract = () => this.accountLendingPool.lendingPool.factory.getRouter();
+        this.getAccount = () => this.accountLendingPool.account.account;
+        this.send = (method, onTransactionHash) => this.interactions.send(method, onTransactionHash);
+        this.interactions = interactions;
+        this.accountLendingPool = accountLendingPool;
+        this.interactionsPoolToken = {
+            [types_1.PoolTokenType.Collateral]: new InteractionsPoolToken_1.default(this, types_1.PoolTokenType.Collateral),
+            [types_1.PoolTokenType.BorrowableA]: new InteractionsPoolToken_1.default(this, types_1.PoolTokenType.BorrowableA),
+            [types_1.PoolTokenType.BorrowableB]: new InteractionsPoolToken_1.default(this, types_1.PoolTokenType.BorrowableB),
+        };
+    }
+    getOwnerSpender() {
+        const router = this.accountLendingPool.lendingPool.factory.getRouter();
+        return {
+            owner: this.accountLendingPool.account.account,
+            spender: router._address,
+        };
+    }
+    getLeverageAmounts(leverage, slippage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [priceA, priceB] = yield this.accountLendingPool.lendingPool.getMarketPriceDenomLP();
+            // This function must use the market price, but the account leverage is calculated with the TWAP, so we need an adjustFactor
+            const [priceATWAP, priceBTWAP] = yield this.accountLendingPool.lendingPool.getPriceDenomLP();
+            const diff = priceA > priceATWAP ? priceA / priceATWAP : priceATWAP / priceA;
+            const adjustFactor = Math.pow((0, utils_1.impermanentLoss)(Math.pow(diff, 2)), leverage);
+            const currentLeverage = yield this.accountLendingPool.getLeverage();
+            const collateralValue = yield this.accountLendingPool.ptc().getDeposited();
+            const changeCollateralValue = (collateralValue * leverage / currentLeverage - collateralValue) * adjustFactor;
+            const valueForEach = changeCollateralValue / 2;
+            const bAmountA = priceA > 0 ? valueForEach / priceA : 0;
+            const bAmountB = priceB > 0 ? valueForEach / priceB : 0;
+            const cAmount = changeCollateralValue ? changeCollateralValue : 0;
+            return {
+                bAmountA: bAmountA,
+                bAmountB: bAmountB,
+                cAmount: cAmount,
+                bAmountAMin: bAmountA / slippage,
+                bAmountBMin: bAmountB / slippage,
+                cAmountMin: cAmount / Math.sqrt(slippage),
+            };
+        });
+    }
+    leverage(amountA, amountB, amountAMin, amountBMin, permitDataA, permitDataB, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const router = this.getRouterContract();
+            const dataA = permitDataA ? permitDataA.permitData : '0x';
+            const dataB = permitDataB ? permitDataB.permitData : '0x';
+            if (permitDataA && permitDataB && !permitDataA.deadline.eq(permitDataB.deadline))
+                return console.error("Permits deadline are not equal");
+            const deadline = permitDataA ? permitDataA.deadline : permitDataB ? permitDataB.deadline : general_1.DEADLINE;
+            const pairAddress = this.getRouterLendingPool().pairAddress;
+            const account = this.accountLendingPool.account.account;
+            return this.send(router.methods.leverage(pairAddress, amountA, amountB, amountAMin, amountBMin, account, deadline, dataA, dataB), onTransactionHash);
+        });
+    }
+    getDeleverageAmounts(changeCollateralAmount, slippage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            changeCollateralAmount = changeCollateralAmount !== null && changeCollateralAmount !== void 0 ? changeCollateralAmount : 0;
+            const [priceA, priceB] = yield this.accountLendingPool.lendingPool.getMarketPriceDenomLP();
+            const valueForEach = changeCollateralAmount / 2;
+            const bAmountA = priceA > 0 ? valueForEach / priceA : 0;
+            const bAmountB = priceB > 0 ? valueForEach / priceB : 0;
+            return {
+                bAmountA: bAmountA,
+                bAmountB: bAmountB,
+                cAmount: changeCollateralAmount,
+                bAmountAMin: bAmountA / Math.sqrt(slippage),
+                bAmountBMin: bAmountB / Math.sqrt(slippage),
+            };
+        });
+    }
+    deleverage(tokens, amountAMin, amountBMin, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const router = this.getRouterContract();
+            const data = permitData ? permitData.permitData : '0x';
+            const deadline = permitData ? permitData.deadline : general_1.DEADLINE;
+            const pairAddress = this.getRouterLendingPool().pairAddress;
+            return this.send(router.methods.deleverage(pairAddress, tokens, amountAMin, amountBMin, deadline, data), onTransactionHash);
+        });
+    }
+    trackBorrows(onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const account = this.accountLendingPool.account.account;
+            const claimAggregator = this.interactions.account.router.contractsHelper.claimAggregator;
+            const toTrack = [];
+            for (const borrowable of [types_1.PoolTokenType.BorrowableA, types_1.PoolTokenType.BorrowableB]) {
+                const b = this.accountLendingPool.accountPoolTokens[borrowable];
+                if ((yield b.getBorrowed()) === 0 || (yield b.getFarmingShares()) > 0)
+                    continue;
+                toTrack.push(yield this.getRouterLendingPool().poolTokens[borrowable].getPoolTokenAddress());
+            }
+            return this.send(claimAggregator.methods.trackBorrows(account, toTrack), onTransactionHash);
+        });
+    }
+    reinvest(onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const account = this.accountLendingPool.account.account;
+            const stakedLPToken = yield this.getRouterLendingPool().getStakedLPToken();
+            return this.send(stakedLPToken.methods.reinvest(), onTransactionHash);
+        });
+    }
+}
+exports.default = InteractionsLendingPool;