impermax-sdk 1.0.1 → 1.0.3

package/impermax-router/Borrowable.ts

@@ -1,86 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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);
-    }
-  }
-}