impermax-sdk 1.0.0

package/impermax-router/Borrowable.ts

@@ -0,0 +1,86 @@
+import { Contract } from "./interfaces";
+
+import PoolToken from "./PoolToken";
+import { Address, PoolTokenType } from '../config/types';
+
+export default class Borrowable extends PoolToken {
+  borrowableCache: {
+    borrowTracker?: Promise<Address>,
+    rewarder?: Promise<Contract>,
+    rewarderTokenSymbol?: Promise<string>,
+    rewardSpeed?: Promise<number>,
+  } = {};
+
+  cleanCache() {
+    super.cleanCache();
+    this.borrowableCache = {};
+  }
+  
+  async initializePoolToken() : Promise<Contract> {
+    return this.getContractHelper().newBorrowable(await this.getPoolTokenAddressFromLendingPool());
+  }
+
+  async initializeToken() : Promise<Contract> {
+    const poolToken = await this.getPoolToken();
+    return this.getContractHelper().newERC20(await poolToken.methods.underlying().call());
+  }
+
+  // Price Denom LP
+  async getPriceDenomLP() {
+    const prices = await this.lendingPool.getPriceDenomLP();
+    return prices[this.poolTokenType === PoolTokenType.BorrowableA ? 0 : 1];
+  }
+  async getMarketPriceDenomLP() {
+    const prices = await this.lendingPool.getMarketPriceDenomLP();
+    return prices[this.poolTokenType === PoolTokenType.BorrowableA ? 0 : 1];
+  }
+
+  // Farming Pool
+  private async initializeBorrowTracker() : Promise<Address> {
+    const borrowable = await this.getPoolToken();
+    return borrowable.methods.borrowTracker().call();
+  }
+  async getBorrowTracker() {
+    if (!this.borrowableCache.borrowTracker) this.borrowableCache.borrowTracker = this.initializeBorrowTracker();
+    return this.borrowableCache.borrowTracker;
+  }
+  async hasFarming() : Promise<boolean> {
+    const borrowTracker = await this.getBorrowTracker();
+    return borrowTracker !== '0x0000000000000000000000000000000000000000';
+  }
+  async hasImpermaxChef() : Promise<boolean> {
+    const borrowTracker = await this.getBorrowTracker();
+    return borrowTracker.toLowerCase() === (this.getImpermaxChef()._address ?? "").toLowerCase();
+  }
+  async getFarmingPool() : Promise<Contract> {
+    if (!await this.hasFarming() || await this.hasImpermaxChef()) return null;
+    return this.getContractHelper().newFarmingPool(await this.getBorrowTracker());
+  }
+  getImpermaxChef = () => this.getContractHelper().impermaxChef;
+  private async initializeRewarder() : Promise<Contract> {
+    const poolTokenAddress = await this.getPoolTokenAddress();
+    try {
+      const { rewarder }  = await this.getImpermaxChef().methods.poolInfo(poolTokenAddress).call();
+      if (rewarder == "0x0000000000000000000000000000000000000000") return null;
+      return this.getContractHelper().newImpermaxChef(rewarder);
+    } catch { return null; }
+  }
+  async getRewarder() {
+    if (!this.borrowableCache.rewarder) this.borrowableCache.rewarder = this.initializeRewarder();
+    return this.borrowableCache.rewarder;
+  }
+  async hasRewarder() : Promise<boolean> {
+    return await this.getRewarder() !== null;
+  }
+  private async initializeRewarderTokenSymbol() : Promise<string> {
+    if (!await this.hasRewarder()) return "";
+    const rewarder  = await this.getRewarder();
+    const rewardTokenAddress = await rewarder.methods.rewardToken().call();
+    return this.getContractHelper().newERC20(rewardTokenAddress).methods.symbol().call();
+  }
+  async getRewarderTokenSymbol() {
+    if (!this.borrowableCache.rewarderTokenSymbol) this.borrowableCache.rewarderTokenSymbol = this.initializeRewarderTokenSymbol();
+    return this.borrowableCache.rewarderTokenSymbol;
+  }
+
+}

package/impermax-router/Collateral.ts

@@ -0,0 +1,26 @@
+import { Contract } from "./interfaces";
+import PoolToken from "./PoolToken";
+
+export default class Collateral extends PoolToken {
+  collateralCache: {
+  } = {};
+
+  cleanCache() {
+    super.cleanCache();
+    this.collateralCache = {};
+  }
+  
+  async initializePoolToken() : Promise<Contract> {
+    return this.lendingPool.factory.router.contractsHelper.newCollateral(await this.getPoolTokenAddressFromLendingPool());
+  }
+  
+  async initializeToken() : Promise<Contract> {
+    return this.lendingPool.getUniswapV2Pair();
+  }
+
+  protected async initializeExchangeRate() : Promise<number> {
+    let exchangeRate = await super.initializeExchangeRate();
+    return exchangeRate * await this.lendingPool.getStakedLPExchangeRate();
+  }
+
+}

package/impermax-router/ContractsHelper.ts

@@ -0,0 +1,64 @@
+import { Contract } from "../impermax-router/interfaces";
+
+import ImpermaxRouter from ".";
+
+import ERC20JSON from '../abis/contracts/IERC20.json';
+import UniswapV2PairJSON from '../abis/contracts/IUniswapV2Pair.json';
+import UniswapV2FactoryJSON from '../abis/contracts/IUniswapV2Factory.json';
+import Router02JSON from '../abis/contracts/IRouter02.json';
+import BorrowableJSON from '../abis/contracts/IBorrowable.json';
+import CollateralJSON from '../abis/contracts/ICollateral.json';
+import StakedLPTokenJSON from '../abis/contracts/IStakedLPToken.json';
+import FactoryJSON from '../abis/contracts/IFactory.json';
+import SimpleUniswapOracleJSON from '../abis/contracts/ISimpleUniswapOracle.json';
+import MerkleDistributorJSON from '../abis/contracts/IMerkleDistributor.json';
+import FarmingPoolJSON from '../abis/contracts/IFarmingPool.json';
+import ClaimAggregatorJSON from '../abis/contracts/ClaimAggregator.json';
+import ClaimableJSON from '../abis/contracts/IClaimable.json';
+import StakingRewardsJSON from '../abis/contracts/IStakingRewards.json';
+import ImpermaxChefJSON from '../abis/contracts/ImpermaxChef.json';
+import { Address } from '../config/types';
+import { IMPERMAX_CHEF } from '../config/contracts/impermax-chef';
+import { CLAIM_AGGREGATOR } from '../config/contracts/claim-aggregators';
+import {
+  MERKLE_DISTRIBUTOR_ETH,
+  MERKLE_DISTRIBUTOR_IBEX,
+  MERKLE_DISTRIBUTOR_IBEX_2
+} from '../config/contracts/merkle-distributors';
+
+export default class ContractsHelper {
+  router: ImpermaxRouter;
+  impermaxChef: Contract;
+  merkleDistributorIbex: Contract;
+  merkleDistributorIbex2: Contract;
+  merkleDistributorEth: Contract;
+  claimAggregator: Contract;
+
+  constructor(router: ImpermaxRouter) {
+    this.router = router;
+    this.impermaxChef = this.newImpermaxChef(IMPERMAX_CHEF[this.router.network]);
+    this.merkleDistributorIbex = this.newMerkleDistributor(MERKLE_DISTRIBUTOR_IBEX[this.router.network]);
+    this.merkleDistributorIbex2 = this.newMerkleDistributor(MERKLE_DISTRIBUTOR_IBEX_2[this.router.network]);
+    this.merkleDistributorEth = this.newMerkleDistributor(MERKLE_DISTRIBUTOR_ETH[this.router.network]);
+    this.claimAggregator = this.newClaimAggregator(CLAIM_AGGREGATOR[this.router.network]);
+  }
+  
+  newContract = (abi: any, address: Address) => new this.router.web3.eth.Contract(abi, address);
+  
+  newRouter =               (address: Address) => this.newContract(Router02JSON.abi, address);
+  newFactory =              (address: Address) => this.newContract(FactoryJSON.abi, address);
+  newSimpleUniswapOracle =  (address: Address) => this.newContract(SimpleUniswapOracleJSON.abi, address);
+  newUniswapV2Pair =        (address: Address) => this.newContract(UniswapV2PairJSON.abi, address);
+  newUniswapV2Factory =     (address: Address) => this.newContract(UniswapV2FactoryJSON.abi, address);
+  newERC20 =                (address: Address) => this.newContract(ERC20JSON.abi, address);
+  newCollateral =           (address: Address) => this.newContract(CollateralJSON.abi, address);
+  newBorrowable =           (address: Address) => this.newContract(BorrowableJSON.abi, address);
+  newStakedLPToken =        (address: Address) => this.newContract(StakedLPTokenJSON.abi, address);
+  newMerkleDistributor =    (address: Address) => this.newContract(MerkleDistributorJSON.abi, address);
+  newFarmingPool =          (address: Address) => this.newContract(FarmingPoolJSON.abi, address);
+  newClaimAggregator =      (address: Address) => this.newContract(ClaimAggregatorJSON.abi, address);
+  newClaimable =            (address: Address) => this.newContract(ClaimableJSON.abi, address);
+  newStakingRewards =       (address: Address) => this.newContract(StakingRewardsJSON.abi, address);
+  newImpermaxChef =         (address: Address) => this.newContract(ImpermaxChefJSON.abi, address);
+  
+}

package/impermax-router/ImpermaxFactory.ts

@@ -0,0 +1,47 @@
+import ImpermaxRouter from ".";
+import LendingPool from "./LendingPool";
+import { Address, Factory } from '../config/types';
+import { SIMPLE_UNISWAP_ORACLE } from '../config/contracts/simple-uniswap-oracles';
+import { ROUTER } from '../config/contracts/routers';
+
+export default class ImpermaxFactory {
+  router: ImpermaxRouter;
+  factory: Factory;
+  lendingPools: {[key in Address]: LendingPool};
+
+  constructor(router: ImpermaxRouter, factory: Factory) {
+    this.router = router;
+    this.factory = factory;
+    this.lendingPools = {};
+  }
+
+  cleanCache() {
+    for (const pairAddress of Object.keys(this.lendingPools) as Address[]) {
+      this.lendingPools[pairAddress].cleanCache();
+    }
+  }
+
+  getSimpleUniswapOracle() {
+    const address = 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 = ROUTER[this.router.network][this.factory];
+    if (!address) {
+      console.error("Router address not found");
+      return null;
+    }
+    return this.router.contractsHelper.newRouter(address);
+  }
+
+  getLendingPool(uniswapV2PairAddress: Address) {
+    if (!this.lendingPools[uniswapV2PairAddress]) this.lendingPools[uniswapV2PairAddress] = new LendingPool(this, uniswapV2PairAddress);
+    return this.lendingPools[uniswapV2PairAddress];
+  }
+  
+}

package/impermax-router/Interactions.ts

@@ -0,0 +1,94 @@
+import { BigNumber } from "ethers";
+import Account from "./Account";
+import AccountBorrowable from "./AccountBorrowable";
+import InteractionsLendingPool from "./InteractionsLendingPool";
+import { AirdropData, Contract } from "./interfaces";
+import { Address, Factory, FactoryIndex, LendingPoolIndex, PoolTokenType } from '../config/types';
+
+const ZERO = BigNumber.from(0);
+
+export default class Interactions {
+  account: Account;
+  interactionsLLPs: LendingPoolIndex<Promise<InteractionsLendingPool>>;
+
+  constructor(account: Account) {
+    this.account = account;
+    this.interactionsLLPs = {};
+  }
+
+  private async initializeInteractionsLendingPool(factory: Factory, pair: Address) : Promise<InteractionsLendingPool> {
+    const lendingPool = await this.account.getAccountLendingPool(factory, pair);
+    return new InteractionsLendingPool(this, lendingPool);
+  }
+  async getInteractionsLendingPool(factory: Factory, pair: Address) : Promise<InteractionsLendingPool> {
+    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];
+  }
+
+  async send(method: any, onTransactionHash: Function, value = ZERO) {
+    try {
+      await method.call({from: this.account.account, value});
+      return method.send({from: this.account.account, value}).on('transactionHash', onTransactionHash);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  async claimAirdrop(airdropData: AirdropData, merkleDistributor: Contract, onTransactionHash: Function) {
+    return this.send(merkleDistributor.methods.claim(airdropData.index, this.account.account, airdropData.amount, airdropData.proof), onTransactionHash);
+  }
+  
+  async claims(pairAddresses: FactoryIndex<Address[]>, onTransactionHash: Function) {
+    const requests: Array<Promise<{
+      hasPendingReward: boolean,
+      hasImpermaxChef: boolean,
+      farmingPool: Contract,
+      borrowableAddress: Address,
+    }>> = [];
+    for (const factory of Object.keys(pairAddresses) as Factory[]) {
+      for (const pairAddress of pairAddresses[factory]) {
+        for (const poolToken of [PoolTokenType.BorrowableA, PoolTokenType.BorrowableB]) {
+          requests.push((async () => {
+            const accountBorrowable = (await this.account.getAccountLendingPool(factory, pairAddress)).accountPoolTokens[poolToken] as AccountBorrowable;
+            const borrowable = accountBorrowable.poolToken;
+            const pendingReward = await accountBorrowable.getAvailableIMXReward() + await accountBorrowable.getAvailableRewarderReward();
+            return {
+              hasPendingReward: pendingReward > 0,
+              hasImpermaxChef: await borrowable.hasImpermaxChef(),
+              farmingPool: await borrowable.getFarmingPool(),
+              borrowableAddress: await borrowable.getPoolTokenAddress(),
+            }
+          })());
+        }
+      }
+    }
+    const data = await 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);
+    }
+  }
+  
+  async claimDistributor(claimableAddress: Address, onTransactionHash: Function) {
+    const claimable = this.account.router.contractsHelper.newClaimable(claimableAddress);
+    return this.send(claimable.methods.claim(), onTransactionHash);
+  }
+
+}

package/impermax-router/InteractionsLendingPool.ts

@@ -0,0 +1,129 @@
+import Interactions from "./Interactions";
+import AccountLendingPool from "./AccountLendingPool";
+import InteractionsPoolToken from "./InteractionsPoolToken";
+import { BigNumber } from "ethers";
+import { impermanentLoss } from "../utils";
+import AccountBorrowable from "./AccountBorrowable";
+import { PoolTokenType } from '../config/types';
+import { DEADLINE } from '../config/general';
+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) {
+    this.interactions = interactions;
+    this.accountLendingPool = accountLendingPool;
+    this.interactionsPoolToken = {
+      [PoolTokenType.Collateral]: new InteractionsPoolToken(this, PoolTokenType.Collateral),
+      [PoolTokenType.BorrowableA]: new InteractionsPoolToken(this, PoolTokenType.BorrowableA),
+      [PoolTokenType.BorrowableB]: new InteractionsPoolToken(this, PoolTokenType.BorrowableB),
+    };
+  }
+
+  getRouterLendingPool = () => this.accountLendingPool.lendingPool;
+  getRouterContract = () => this.accountLendingPool.lendingPool.factory.getRouter();
+  getAccount = () => this.accountLendingPool.account.account;
+  send = (method: any, onTransactionHash: Function) => this.interactions.send(method, onTransactionHash);
+  
+  getOwnerSpender() {
+    const router = this.accountLendingPool.lendingPool.factory.getRouter();
+    return {
+      owner: this.accountLendingPool.account.account,
+      spender: router._address,
+    }
+  }
+  
+  async getLeverageAmounts(leverage: number, slippage: number) {
+    const [priceA, priceB] = await 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] = await this.accountLendingPool.lendingPool.getPriceDenomLP();
+    const diff = priceA > priceATWAP ? priceA / priceATWAP : priceATWAP / priceA;
+    const adjustFactor = Math.pow(impermanentLoss(diff**2), leverage);
+    const currentLeverage = await this.accountLendingPool.getLeverage();
+    const collateralValue = await 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),
+    };
+  }
+  async leverage(
+    amountA: BigNumber, 
+    amountB: BigNumber,
+    amountAMin: BigNumber, 
+    amountBMin: BigNumber,
+    permitDataA: PermitData, 
+    permitDataB: PermitData, 
+    onTransactionHash: 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 : 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);
+  }
+
+  async getDeleverageAmounts(changeCollateralAmount: number, slippage: number) {
+    changeCollateralAmount = changeCollateralAmount ?? 0;
+    const [priceA, priceB] = await 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),
+    };
+  }
+  async deleverage(
+    tokens: BigNumber, 
+    amountAMin: BigNumber, 
+    amountBMin: BigNumber,
+    permitData: PermitData, 
+    onTransactionHash: Function
+  ) {
+    const router = this.getRouterContract();
+    const data = permitData ? permitData.permitData : '0x';
+    const deadline = permitData ? permitData.deadline : DEADLINE;
+    const pairAddress = this.getRouterLendingPool().pairAddress;
+    return this.send(router.methods.deleverage(pairAddress, tokens, amountAMin, amountBMin, deadline, data), onTransactionHash);
+  }
+
+  async trackBorrows(onTransactionHash: Function) {
+    const account = this.accountLendingPool.account.account;
+    const claimAggregator = this.interactions.account.router.contractsHelper.claimAggregator;
+    const toTrack = [];
+    for (const borrowable of [PoolTokenType.BorrowableA, PoolTokenType.BorrowableB]) {
+      const b = this.accountLendingPool.accountPoolTokens[borrowable] as AccountBorrowable;
+      if (await b.getBorrowed() === 0 || await b.getFarmingShares() > 0) continue;
+      toTrack.push(await this.getRouterLendingPool().poolTokens[borrowable].getPoolTokenAddress());
+    }
+    return this.send(claimAggregator.methods.trackBorrows(account, toTrack), onTransactionHash);
+  }
+  
+  async reinvest(onTransactionHash: Function) {
+    const account = this.accountLendingPool.account.account;
+    const stakedLPToken = await this.getRouterLendingPool().getStakedLPToken();
+    return this.send(stakedLPToken.methods.reinvest(), onTransactionHash);
+  }
+}

package/impermax-router/InteractionsPoolToken.ts

@@ -0,0 +1,187 @@
+import { ethers, BigNumber } from "ethers";
+import AccountPoolToken from "./AccountPoolToken";
+import InteractionsLendingPool from "./InteractionsLendingPool";
+import { ApprovalType, PermitData } from "./interfaces";
+import { PoolTokenType } from '../config/types';
+import { WETH } from '../config/contracts/weths';
+import { DEADLINE } from '../config/general';
+
+const MAX_UINT256 = 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,
+}
+
+export default class InteractionsPoolToken {
+  interactionsLendingPool: InteractionsLendingPool;
+  accountPoolToken: AccountPoolToken;
+
+  constructor(interactionsLendingPool: InteractionsLendingPool, poolTokenType: PoolTokenType) {
+    this.interactionsLendingPool = interactionsLendingPool;
+    this.accountPoolToken = interactionsLendingPool.accountLendingPool.accountPoolTokens[poolTokenType];
+  }
+
+  // Shortcuts
+  getImpermaxRouter = () => this.interactionsLendingPool.interactions.account.router;
+  getPoolToken = () => this.accountPoolToken.poolToken;
+  getRouterContract = () => this.interactionsLendingPool.accountLendingPool.lendingPool.factory.getRouter();
+  send = (method: any, onTransactionHash: Function, value?: BigNumber) => this.interactionsLendingPool.interactions.send(method, onTransactionHash, value);
+
+  async isWETH() {
+    const token = await this.getPoolToken().getToken();
+    return token._address.toLowerCase() == WETH[this.getImpermaxRouter().network].toLowerCase();
+  }
+
+  isCollateral() {
+    return this.getPoolToken().poolTokenType == PoolTokenType.Collateral;
+  }
+
+  async getAllowance(approvalType: ApprovalType) {
+    const poolToken = await this.getPoolToken().getPoolToken();
+    const token = await this.getPoolToken().getToken();
+    if (await this.isWETH() && approvalType == ApprovalType.UNDERLYING) return MAX_UINT256;
+    const {owner, spender} = this.interactionsLendingPool.getOwnerSpender();
+    const allowance =
+      (approvalType == ApprovalType.POOL_TOKEN) ? await poolToken.methods.allowance(owner, spender).call() :
+      (approvalType == ApprovalType.UNDERLYING) ? await token.methods.allowance(owner, spender).call() :
+      (approvalType == ApprovalType.BORROW) ? await poolToken.methods.borrowAllowance(owner, spender).call() : 0;
+    return BigNumber.from(allowance);
+  }
+  
+  async approve(approvalType: ApprovalType, amount: BigNumber, onTransactionHash: Function) {
+    const {spender} = this.interactionsLendingPool.getOwnerSpender();
+    const poolToken = await this.getPoolToken().getPoolToken();
+    const token = await this.getPoolToken().getToken();
+    let method;
+    if (approvalType == ApprovalType.POOL_TOKEN) method = poolToken.methods.approve(spender, amount);
+    if (approvalType == ApprovalType.UNDERLYING) method = token.methods.approve(spender, amount);
+    if (approvalType == ApprovalType.BORROW) method = poolToken.methods.borrowApprove(spender, amount);
+    return this.send(method, onTransactionHash);
+  }
+  
+  async getPermitData(
+    approvalType: ApprovalType, 
+    amount: BigNumber, 
+    deadlineArg: BigNumber | null,
+    callBack: (permitData: PermitData) => void
+  ) {
+    if (approvalType === ApprovalType.UNDERLYING && this.getPoolToken().poolTokenType != PoolTokenType.Collateral) return callBack(null);
+    const {owner, spender} = this.interactionsLendingPool.getOwnerSpender();
+    const poolToken = await this.getPoolToken().getPoolToken();
+    const token = await this.getPoolToken().getToken();
+    const contract = approvalType == ApprovalType.UNDERLYING ? token : poolToken;
+    const nonce = await contract.methods.nonces(owner).call();
+    const name = await contract.methods.name().call();
+    const deadline = deadlineArg ? deadlineArg : DEADLINE;
+  
+    const data = JSON.stringify({
+      types: TYPES,
+      domain: {
+        name: name,
+        version: "1",
+        chainId: this.getImpermaxRouter().chainId,
+        verifyingContract: contract._address,
+      },
+      primaryType: approvalType == ApprovalType.BORROW ? "BorrowPermit" : "Permit",
+      message: {
+        owner: owner, 
+        spender: spender, 
+        value: amount.toString(),
+        nonce: BigNumber.from(nonce).toHexString(),
+        deadline: deadline.toNumber(),
+      }
+    });
+    
+    this.getImpermaxRouter().web3.currentProvider.send(
+      {
+        method: "eth_signTypedData_v4",
+        params: [owner, data],
+        from: owner
+      },
+      (err: any, data: any) => {
+        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: string = ethers.utils.defaultAbiCoder.encode(
+          ['bool', 'uint8', 'bytes32', 'bytes32'],
+          [false, v, r, s]
+        );
+        callBack({permitData, deadline, amount});
+      }
+    );
+  }
+
+  async deposit(amount: BigNumber, permitData: PermitData, onTransactionHash: Function) {
+    const router = this.getRouterContract();
+    const poolToken = await this.getPoolToken().getPoolToken();
+    const data = permitData ? permitData.permitData : '0x';
+    const deadline = permitData ? permitData.deadline : DEADLINE;
+    const account = this.accountPoolToken.getAccount();
+    if (await 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);
+    }
+  }
+
+  async withdraw(tokens: BigNumber, permitData: PermitData, onTransactionHash: Function) {
+    const router = this.getRouterContract();
+    const poolToken = await this.getPoolToken().getPoolToken();
+    const data = permitData ? permitData.permitData : '0x';
+    const deadline = permitData ? permitData.deadline : DEADLINE;
+    const account = this.accountPoolToken.getAccount();
+    if (await 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);
+    }
+  }
+
+  async borrow(amount: BigNumber, permitData: PermitData, onTransactionHash: Function) {
+    const router = this.getRouterContract();
+    const borrowable = await this.getPoolToken().getPoolToken();
+    const data = permitData ? permitData.permitData : '0x';
+    const deadline = permitData ? permitData.deadline : DEADLINE;
+    const account = this.accountPoolToken.getAccount();
+    if (await 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);
+    }
+  }
+  
+  async repay(amount: BigNumber, onTransactionHash: Function) {
+    const router = this.getRouterContract();
+    const borrowable = await this.getPoolToken().getPoolToken();
+    const account = this.accountPoolToken.getAccount();
+    if (await this.isWETH()) {
+      return this.send(router.methods.repayETH(borrowable._address, account, DEADLINE), onTransactionHash, amount);
+    } else {
+      return this.send(router.methods.repay(borrowable._address, amount, account, DEADLINE), onTransactionHash);
+    }
+  }
+}