impermax-sdk 1.2.112 → 2.0.0

package/lib/onchain/account/interactions/index.d.ts

@@ -0,0 +1,28 @@
+import { BigNumber } from "ethers";
+import Account from "../index";
+import * as lendingPool from './lendingPool';
+import LendingPool from "./lendingPool";
+import PoolToken from "./poolToken";
+import { AirdropData, Contract } from "../../types";
+import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex } from '../../../config/types';
+import LendingVault from './lendingVault';
+export { lendingPool, LendingPool, PoolToken, LendingVault, };
+export default class Interactions {
+    account: Account;
+    interactionsLLPs: LendingPoolIndex<Promise<LendingPool>>;
+    interactionsLVs: AddressIndex<Promise<LendingVault>>;
+    cache: {
+        defaultRouterContract?: Contract;
+    };
+    constructor(account: Account);
+    cleanCache(): Promise<void>;
+    private initializeInteractionsLendingPool;
+    getInteractionsLendingPool(factory: Factory, pair: Address): Promise<LendingPool>;
+    private initializeInteractionsLendingVault;
+    getInteractionsLendingVault(vaultAddress: Address): Promise<LendingVault>;
+    send(method: any, onTransactionHash: Function, value?: BigNumber): Promise<any>;
+    getDefaultRouterContract(): 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/onchain/account/interactions/index.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __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 });
+exports.LendingVault = exports.PoolToken = exports.LendingPool = exports.lendingPool = void 0;
+const ethers_1 = require("ethers");
+const lendingPool = __importStar(require("./lendingPool"));
+exports.lendingPool = lendingPool;
+const lendingPool_1 = __importDefault(require("./lendingPool"));
+exports.LendingPool = lendingPool_1.default;
+const poolToken_1 = __importDefault(require("./poolToken"));
+exports.PoolToken = poolToken_1.default;
+const types_1 = require("../../../config/types");
+const lendingVault_1 = __importDefault(require("./lendingVault"));
+exports.LendingVault = lendingVault_1.default;
+const routers_1 = require("../../../config/contracts/routers");
+const ZERO = ethers_1.BigNumber.from(0);
+class Interactions {
+    constructor(account) {
+        this.cache = {};
+        this.account = account;
+        this.interactionsLLPs = {};
+        this.interactionsLVs = {};
+    }
+    cleanCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cache = {};
+        });
+    }
+    initializeInteractionsLendingPool(factory, pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.account.getLendingPool(factory, pair);
+            return new lendingPool_1.default(this, lendingPool);
+        });
+    }
+    getInteractionsLendingPool(factory, pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.interactionsLLPs[factory])
+                this.interactionsLLPs[factory] = {};
+            const interactionsLendingPools = this.interactionsLLPs[factory];
+            if (!interactionsLendingPools[pair])
+                interactionsLendingPools[pair] = this.initializeInteractionsLendingPool(factory, pair);
+            return interactionsLendingPools[pair];
+        });
+    }
+    initializeInteractionsLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingVault = yield this.account.getLendingVault(vaultAddress);
+            return new lendingVault_1.default(this, lendingVault);
+        });
+    }
+    getInteractionsLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.interactionsLVs[vaultAddress])
+                this.interactionsLVs[vaultAddress] = this.initializeInteractionsLendingVault(vaultAddress);
+            return this.interactionsLVs[vaultAddress];
+        });
+    }
+    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);
+            }
+        });
+    }
+    getDefaultRouterContract() {
+        if (!this.cache.defaultRouterContract) {
+            const address = routers_1.DEFAULT_ROUTER[this.account.onchain.network];
+            if (!address) {
+                console.error("SimpleUniswapOracle address not found");
+                return null;
+            }
+            this.cache.defaultRouterContract = this.account.onchain.contractsHelper.newRouterV2(address);
+        }
+        return this.cache.defaultRouterContract;
+    }
+    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 in 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.getLendingPool(factory, pairAddress)).accountPoolTokens[poolToken];
+                            const borrowable = accountBorrowable.offchainPoolToken;
+                            const pendingReward = (yield accountBorrowable.getAvailableFarmingReward()) + (yield accountBorrowable.getAvailableRewarderReward());
+                            return {
+                                hasPendingReward: pendingReward > 0,
+                                hasImpermaxChef: yield borrowable.hasImpermaxChef(),
+                                borrowableAddress: yield borrowable.getPoolTokenAddress(),
+                            };
+                        }))());
+                    }
+                }
+            }
+            const data = yield Promise.all(requests);
+            const toClaim = [];
+            for (const borrowable of data) {
+                if (!borrowable.hasPendingReward)
+                    continue;
+                toClaim.push(borrowable.borrowableAddress);
+            }
+            if (toClaim.length > 0) {
+                const impermaxChef = this.account.onchain.contractsHelper.impermaxChef;
+                return this.send(impermaxChef.methods.massHarvest(toClaim, this.account.account), onTransactionHash);
+            }
+        });
+    }
+    claimDistributor(claimableAddress, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const claimable = this.account.onchain.contractsHelper.newClaimable(claimableAddress);
+            return this.send(claimable.methods.claim(), onTransactionHash);
+        });
+    }
+}
+exports.default = Interactions;

package/lib/onchain/account/interactions/lendingPool/borrowable.d.ts

@@ -0,0 +1,16 @@
+import { PoolTokenType } from '../../../../config/types';
+import LendingPool from './index';
+import { PermitData } from '../../../types';
+import { BigNumber } from 'ethers';
+import * as account from '../../index';
+import PoolToken from '../poolToken';
+export default class Borrowable extends PoolToken {
+    interactionsLendingPool: LendingPool;
+    accountPoolToken: account.lendingPool.Borrowable;
+    constructor(interactionsLendingPool: LendingPool, poolTokenType: PoolTokenType);
+    getInteractions: () => account.interactions.default;
+    getAccountAddress: () => string;
+    getRouterContract: () => any;
+    borrow(amount: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+    repay(amount: BigNumber, onTransactionHash: Function): Promise<any>;
+}

package/lib/onchain/account/interactions/lendingPool/borrowable.js

@@ -0,0 +1,49 @@
+"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 general_1 = require("../../../../config/general");
+const poolToken_1 = __importDefault(require("../poolToken"));
+class Borrowable extends poolToken_1.default {
+    constructor(interactionsLendingPool, poolTokenType) {
+        super();
+        this.getInteractions = () => this.interactionsLendingPool.interactions;
+        this.getAccountAddress = () => this.interactionsLendingPool.getAccountAddress();
+        this.getRouterContract = () => this.interactionsLendingPool.getRouterContract();
+        this.interactionsLendingPool = interactionsLendingPool;
+        this.accountPoolToken = interactionsLendingPool.lendingPool.accountPoolTokens[poolTokenType];
+    }
+    borrow(amount, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { router, ptAddress, account, data, deadline } = yield this.getSendData(permitData);
+            if (yield this.isWETH()) {
+                return this.send(router.methods.borrowETH(ptAddress, amount, account, deadline, data), onTransactionHash);
+            }
+            else {
+                return this.send(router.methods.borrow(ptAddress, amount, account, deadline, data), onTransactionHash);
+            }
+        });
+    }
+    repay(amount, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { router, ptAddress, account } = yield this.getSendData(null);
+            if (yield this.isWETH()) {
+                return this.send(router.methods.repayETH(ptAddress, account, general_1.DEADLINE), onTransactionHash, amount);
+            }
+            else {
+                return this.send(router.methods.repay(ptAddress, amount, account, general_1.DEADLINE), onTransactionHash);
+            }
+        });
+    }
+}
+exports.default = Borrowable;

package/lib/onchain/account/interactions/lendingPool/collateral.d.ts

@@ -0,0 +1,15 @@
+import { PoolTokenType } from '../../../../config/types';
+import LendingPool from './index';
+import { PermitData } from '../../../types';
+import { BigNumber } from 'ethers';
+import * as account from '../../index';
+import PoolToken from '../poolToken';
+export default class Collateral extends PoolToken {
+    interactionsLendingPool: LendingPool;
+    accountPoolToken: account.lendingPool.Collateral;
+    constructor(interactionsLendingPool: LendingPool, poolTokenType: PoolTokenType);
+    getInteractions: () => account.interactions.default;
+    getAccountAddress: () => string;
+    getRouterContract: () => any;
+    protected mint(amount: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+}

package/lib/onchain/account/interactions/lendingPool/collateral.js

@@ -0,0 +1,33 @@
+"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(interactionsLendingPool, poolTokenType) {
+        super();
+        this.getInteractions = () => this.interactionsLendingPool.interactions;
+        this.getAccountAddress = () => this.interactionsLendingPool.getAccountAddress();
+        this.getRouterContract = () => this.interactionsLendingPool.getRouterContract();
+        this.interactionsLendingPool = interactionsLendingPool;
+        this.accountPoolToken = interactionsLendingPool.lendingPool.accountPoolTokens[poolTokenType];
+    }
+    mint(amount, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { router, ptAddress, account, data, deadline } = yield this.getSendData(permitData);
+            return this.send(router.methods.mintCollateral(ptAddress, amount, account, deadline, data), onTransactionHash);
+        });
+    }
+    ;
+}
+exports.default = Collateral;

package/lib/onchain/account/interactions/lendingPool/index.d.ts

@@ -0,0 +1,41 @@
+import Interactions from "../index";
+import { BigNumber } from "ethers";
+import { PoolTokenType } from '../../../../config/types';
+import { PermitData } from '../../../types';
+import Collateral from './collateral';
+import Borrowable from './borrowable';
+import * as account from '../../index';
+export { Borrowable, Collateral, };
+export default class LendingPool {
+    interactions: Interactions;
+    accountLendingPool: account.LendingPool;
+    interactionsPoolToken: {
+        [PoolTokenType.Collateral]: Collateral;
+        [PoolTokenType.BorrowableA]: Borrowable;
+        [PoolTokenType.BorrowableB]: Borrowable;
+    };
+    constructor(interactions: Interactions, accountLendingPool: account.LendingPool);
+    getRouterLendingPool: () => import("../../../impermaxFactory").LendingPool;
+    getRouterContract: () => any;
+    getAccountAddress: () => string;
+    send: (method: any, onTransactionHash: Function) => Promise<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/onchain/account/interactions/lendingPool/index.js

@@ -0,0 +1,120 @@
+"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 });
+exports.Collateral = exports.Borrowable = void 0;
+const utils_1 = require("../../../../utils");
+const types_1 = require("../../../../config/types");
+const general_1 = require("../../../../config/general");
+const collateral_1 = __importDefault(require("./collateral"));
+exports.Collateral = collateral_1.default;
+const borrowable_1 = __importDefault(require("./borrowable"));
+exports.Borrowable = borrowable_1.default;
+class LendingPool {
+    constructor(interactions, accountLendingPool) {
+        this.getRouterLendingPool = () => this.accountLendingPool.lendingPool;
+        this.getRouterContract = () => this.accountLendingPool.lendingPool.factory.getRouter();
+        this.getAccountAddress = () => 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 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),
+        };
+    }
+    getLeverageAmounts(leverage, slippage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [priceA, priceB] = yield this.lendingPool.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.lendingPool.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.lendingPool.getLeverage();
+            const collateralValue = yield this.lendingPool.getCollateral().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.lendingPool.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.lendingPool.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.lendingPool.account.account;
+            const claimAggregator = this.interactions.account.onchain.contractsHelper.claimAggregator;
+            const toTrack = [];
+            for (const borrowable of [types_1.PoolTokenType.BorrowableA, types_1.PoolTokenType.BorrowableB]) {
+                const b = this.lendingPool.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 stakedLPToken = yield this.getRouterLendingPool().getStakedLPToken();
+            return this.send(stakedLPToken.methods.reinvest(), onTransactionHash);
+        });
+    }
+}
+exports.default = LendingPool;

package/lib/onchain/account/interactions/lendingVault.d.ts

@@ -0,0 +1,10 @@
+import Interactions from "./index";
+import * as account from '../index';
+export default class LendingVault {
+    interactions: Interactions;
+    accountLendingVault: account.LendingVault;
+    constructor(interactions: Interactions, accountLendingVault: account.LendingVault);
+    getInteractions: () => Interactions;
+    getAccountAddress: () => string;
+    getRouterContract: () => any;
+}

package/lib/onchain/account/interactions/lendingVault.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class LendingVault {
+    constructor(interactions, accountLendingVault) {
+        this.getInteractions = () => this.interactions;
+        this.getAccountAddress = () => this.accountLendingVault.account.account;
+        this.getRouterContract = () => this.getInteractions().getDefaultRouterContract();
+        this.interactions = interactions;
+        this.accountLendingVault = accountLendingVault;
+    }
+}
+exports.default = LendingVault;

package/lib/onchain/account/interactions/poolToken.d.ts

@@ -0,0 +1,33 @@
+import { ethers, BigNumber } from "ethers";
+import { ApprovalType, Contract, PermitData } from "../../types";
+import { Address } from '../../../config/types';
+import Interactions from './index';
+import * as onchain from '../../index';
+export default abstract class PoolToken {
+    accountPoolToken: onchain.account.PoolToken;
+    abstract getInteractions(): Interactions;
+    abstract getAccountAddress(): Address;
+    abstract getRouterContract(): Contract;
+    getImpermaxRouter: () => onchain.default;
+    getPoolToken: () => onchain.PoolToken;
+    send(method: any, onTransactionHash: Function, value?: BigNumber): Promise<any>;
+    getOwnerSpender(): {
+        owner: string;
+        spender: any;
+    };
+    isWETH(): Promise<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 | null) => void): Promise<void>;
+    protected getSendData(permitData: PermitData | null): Promise<{
+        router: any;
+        ptAddress: any;
+        account: string;
+        data: string;
+        deadline: ethers.BigNumber;
+    }>;
+    protected mintETH(amount: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+    protected mint(amount: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+    deposit(amount: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+    withdraw(tokens: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<any>;
+}