impermax-sdk 1.0.1 → 1.0.2

package/config/types.ts

@@ -1,81 +0,0 @@
-import { BigNumber } from 'ethers';
-
-export enum Networks {
-  Ropsten = 'ropsten',
-  Mainnet = 'mainnet',
-  Polygon = 'polygon',
-  Arbitrum = 'arbitrum',
-  Avalanche = 'avalanche',
-  Moonriver = 'moonriver',
-  Aurora = 'aurora',
-  Cronos = 'cronos',
-  Fantom = 'fantom',
-  Harmony = 'harmony',
-  Moonbeam = 'moonbeam',
-  Sxnetwork = 'sxnetwork',
-}
-
-// FACTORIES
-export enum Factory {
-  V2V1 = '1',     // Uniswap V2 Factory V1
-  V2V1_1 = '2',   // Uniswap V2 Factory V1 (removed factory parameter)
-  V2V1_2 = '3',   // Uniswap V2 Factory V1 (updated interest rate model and no borrow fee)
-  V2V2 = '4',     // Uniswap V2 Factory V2 (liquidation fee)
-  SOLV1_2 = '5',  // Solidly Factory V1
-  SOLV2 = '6',    // Solidly Factory V2
-}
-
-export enum PoolTokenType {
-  Collateral = 'collateral',
-  BorrowableA = 'borrowable0',
-  BorrowableB = 'borrowable1',
-}
-
-export enum Amms {
-  uniswap = 'uniswap',
-  quickswap = 'quickswap',
-  sushiswap = 'sushiswap',
-  swapr = 'swapr',
-  swapfish = 'swapfish',
-  zyberswap = 'zyberswap',
-  pangolin = 'pangolin',
-  traderJoe = 'traderJoe',
-  solarbeam = 'solarbeam',
-  thorus = 'thorus',
-  tetuswap = 'tetuswap',
-  solidly = 'solidly',
-  solidlyB = 'solidlyB',
-  solidlyUSDC = 'solidlyUSDC',
-  solidlyUSDCB = 'solidlyUSDCB',
-  solidly091 = 'solidly091',
-  solidlyOxd = 'solidlyOxd',
-}
-
-export type Address = string;
-
-export type NetworkIndex<Type> = {
-  [key in Networks]?: Type
-};
-
-export type FactoryIndex<Type> = {
-  [key in Factory]?: Type
-};
-
-export type AddressIndex<Type> = {
-  [key in Address]: Type
-};
-
-export type NetworkFactoryIndex<Type> = NetworkIndex<FactoryIndex<Type>>;
-
-export type LendingPoolIndex<Type> = FactoryIndex<AddressIndex<Type>>;
-
-export type AmmIndex = {
-  [key in Networks]: {
-    [key in Amms]?: any
-  }
-};
-
-export type DistributorDetails = {
-  claimableAddress: Address,
-  name: string,
-};

package/impermax-router/Account.ts

@@ -1,123 +0,0 @@
-import { AirdropData, Contract, PendingRewardUI } from "../impermax-router/interfaces";
-
-import ImpermaxRouter from ".";
-import AccountLendingPool from "./AccountLendingPool";
-import { BigNumber } from "ethers";
-import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
-import { MERKLE_URL_ETH, MERKLE_URL_IBEX, MERKLE_URL_IBEX_2 } from '../config/endpoints/merkle-distributors';
-
-export default class Account {
-  router: ImpermaxRouter;
-  account: Address;
-  accountLLPs: LendingPoolIndex<Promise<AccountLendingPool>>;
-  cache: {
-    airdropData: {[key in string]?: Promise<AirdropData>},
-    claimableIBEX?: {
-      [key in Address]?: Promise<number>
-    },
-  } = { airdropData: {} };
-
-  constructor(router: ImpermaxRouter, account: Address) {
-    this.router = router;
-    this.account = account;
-    this.accountLLPs = {};
-    this.cache.claimableIBEX = {};
-  }
-
-  async cleanCache() {
-    this.cache = { airdropData: {} };
-    this.cache.claimableIBEX = {};
-    for (const factory of Object.keys(this.accountLLPs) as Factory[]) {
-      for (const pairAddress of Object.keys(this.accountLLPs[factory]) as Address[]) {
-        (await this.accountLLPs[factory][pairAddress]).cleanCache()
-      }
-    }
-  }
-
-  private async initializeAccountLendingPool(factory: Factory, pair: Address) : Promise<AccountLendingPool> {
-    const lendingPool = await this.router.getFactory(factory).getLendingPool(pair);
-    return new AccountLendingPool(this, lendingPool);
-  }
-  async getAccountLendingPool(factory: Factory, pair: Address) : Promise<AccountLendingPool> {
-    if (!this.accountLLPs[factory]) this.accountLLPs[factory] = {};
-    if (!this.accountLLPs[factory][pair]) this.accountLLPs[factory][pair] = this.initializeAccountLendingPool(factory, pair);
-    return this.accountLLPs[factory][pair];
-  }
-
-  // Mass Available Reward (only supports ImpermaxChef)
-  async getMassAvailableReward(pairs: FactoryIndex<Address[]>) : Promise<LendingPoolIndex<PendingRewardUI[]>> {
-    const result: LendingPoolIndex<PendingRewardUI[]> = {};
-    if (!pairs) return result;
-    const requests = [];
-    const factories = Object.keys(pairs) as Factory[];
-    for (const factory of factories) {
-      const requestsLocal = [];
-      for (const pairAddress of pairs[factory]) {
-        requestsLocal.push((await this.getAccountLendingPool(factory, pairAddress)).getAvailableReward());
-      }
-      requests.push(Promise.all(requestsLocal));
-    }
-    const data = await Promise.all(requests);
-    for (let i = 0; i < factories.length; i++) {
-      const factory = factories[i];
-      result[factory] = {};
-      for (let j = 0; j < pairs[factory].length; j++) {
-        result[factory][pairs[factory][j]] = data[i][j];
-      }
-    }
-    return result;
-  }
-
-  // Airdrop Data
-  private async initializeAirdropData(airdropURL: string, merkleDistributor: Contract) : Promise<AirdropData> {
-    if (airdropURL && airdropURL !== '') {
-      try {
-        const json = await fetch(airdropURL + '/' + this.account);
-        const data = await json.json();
-        if (data) {
-          data.amount = BigNumber.from(data.amount);
-          const isClaimed = await merkleDistributor.methods.isClaimed(data.index).call();
-          if (!isClaimed) return data;
-        }
-      } catch (e){}
-    }
-    return {
-      index: -1,
-      amount: null,
-      proof: [],
-    }
-  }
-  private async getAirdropData(airdropURL: string, merkleDistributor: Contract) : Promise<AirdropData> {
-    if (!this.cache.airdropData[airdropURL]) this.cache.airdropData[airdropURL] = this.initializeAirdropData(airdropURL, merkleDistributor);
-    return this.cache.airdropData[airdropURL];
-  }
-  async getIbexAirdropData() : Promise<AirdropData> {
-    return this.getAirdropData(MERKLE_URL_IBEX[this.router.network], this.router.contractsHelper.merkleDistributorIbex);
-  }
-  async getIbex2AirdropData() : Promise<AirdropData> {
-    return this.getAirdropData(MERKLE_URL_IBEX_2[this.router.network], this.router.contractsHelper.merkleDistributorIbex2);
-  }
-  async getEthAirdropData() : Promise<AirdropData> {
-    return this.getAirdropData(MERKLE_URL_ETH[this.router.network], this.router.contractsHelper.merkleDistributorEth);
-  }
-  async hasIbexClaimableAirdrop() : Promise<boolean> {
-    const airdropData = await this.getIbexAirdropData();
-    if (airdropData.amount) return true;
-    return false;
-  }
-  async hasEthClaimableAirdrop() : Promise<boolean> {
-    const airdropData = await this.getEthAirdropData();
-    if (airdropData.amount) return true;
-    return false;
-  }
-
-  // Claim Claimable IBEX
-  async initializeClaimableIBEX(claimableAddress: Address) : Promise<number> {
-    const claimable = this.router.contractsHelper.newClaimable(claimableAddress);
-    return await claimable.methods.claim().call({from: this.account}) / 1e18;
-  }
-  async getClaimableIBEX(claimableAddress: Address) : Promise<number> {
-    if (!this.cache.claimableIBEX[claimableAddress]) this.cache.claimableIBEX[claimableAddress] = this.initializeClaimableIBEX(claimableAddress);
-    return this.cache.claimableIBEX[claimableAddress];
-  }
-}

package/impermax-router/AccountBorrowable.ts

@@ -1,110 +0,0 @@
-import { NO_CHANGES } from "./interfaces";
-
-import AccountPoolToken from "./AccountPoolToken";
-import Borrowable from "./Borrowable";
-import { PoolTokenType } from '../config/types';
-
-export default class AccountBorrowable extends AccountPoolToken {
-  poolToken: Borrowable;
-  borrowableCache: {
-    borrowed?: Promise<number>,
-    farmingShares?: Promise<number>,
-    availableIMXReward?: Promise<number>,
-    availableRewarderReward?: Promise<number>,
-  } = {};
-
-  cleanCache() {
-    super.cleanCache();
-    this.borrowableCache = {};
-  }
-  
-  // Borrowed
-  private async initializeBorrowed() : Promise<number> {
-    const borrowable = await this.poolToken.getPoolToken();
-    const balance = await borrowable.methods.borrowBalance(this.getAccount()).call();
-    const storedAmount = await await this.poolToken.normalize(balance);
-    const accrualTimestamp = await this.getAccrualTimestamp();
-    const borrowRate = await this.getBorrowRate();
-    return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * borrowRate);
-  }
-  async getBorrowed() : Promise<number> {
-    if (!this.borrowableCache.borrowed) this.borrowableCache.borrowed = this.initializeBorrowed();
-    return this.borrowableCache.borrowed;
-  }
-  async getBorrowedUSD() : Promise<number> {
-    const borrowed = await this.getBorrowed();
-    const tokenPrice = await this.getTokenPriceAccurate();
-    return borrowed * tokenPrice;
-  }
-
-  // Max Borrowable
-  async getMaxBorrowable() : Promise<number> {
-    const availableCash = await this.poolToken.getTotalBalance();
-    const { valueCollateral, valueA, valueB } = await this.accountLendingPool.getValues(NO_CHANGES);
-    const [valueBorrowed, valueOther] = this.poolToken.poolTokenType == PoolTokenType.BorrowableA ? [valueA, valueB] : [valueB, valueA];
-    const safetyMargin = (await this.accountLendingPool.getSafetyMargin()) * this.getUiMargin();
-    const liquidationPenalty = await this.accountLendingPool.getLiquidationPenalty();
-    const actualCollateral = valueCollateral / liquidationPenalty;
-    const totalValueBorrowable1 = (actualCollateral * Math.sqrt(safetyMargin) - valueOther) / safetyMargin;
-    const totalValueBorrowable2 = (actualCollateral / Math.sqrt(safetyMargin) - valueOther) * safetyMargin;
-    const maxValueBorrowable = Math.min(totalValueBorrowable1, totalValueBorrowable2) - valueBorrowed;
-    const price = await this.poolToken.getMarketPriceDenomLP();
-    return Math.max(0, Math.min(availableCash, maxValueBorrowable / price));
-  }
-
-  // Farming Shares
-  private async initializeFarmingShares() : Promise<number> {
-    if (!await this.poolToken.hasFarming()) return 0;
-    if (await this.poolToken.hasImpermaxChef()) {
-      const c = (await this.poolToken.getImpermaxChef().methods.userInfo(
-        await this.poolToken.getPoolTokenAddress(), 
-        this.getAccount()
-      ).call()).shares;
-      return c
-    } else {
-      const farmingPool = await this.poolToken.getFarmingPool();
-      return (await farmingPool.methods.recipients(this.getAccount()).call()).shares;
-    }
-  }
-  async getFarmingShares() : Promise<number> {
-    if (!this.borrowableCache.farmingShares) this.borrowableCache.farmingShares = this.initializeFarmingShares();
-    return this.borrowableCache.farmingShares;
-  }
-
-  // Available Reward
-  private async initializeAvailableIMXReward() : Promise<number> {
-    if (!await this.poolToken.hasFarming()) return 0;
-    if (await this.poolToken.hasImpermaxChef()) {
-      const borrowableAddress = await this.poolToken.getPoolTokenAddress();
-      try {
-        return await this.poolToken.getImpermaxChef().methods.pendingReward(borrowableAddress, this.getAccount()).call() / 1e18;
-      } catch {
-        console.log("Warning: pending reward negative");
-        return 0;
-      }
-    } else {
-      const farmingPool = await this.poolToken.getFarmingPool();
-      return await farmingPool.methods.claim().call({from: this.getAccount()}) / 1e18;
-    }
-  }
-  async getAvailableIMXReward() {
-    if (!this.borrowableCache.availableIMXReward) this.borrowableCache.availableIMXReward = this.initializeAvailableIMXReward();
-    return this.borrowableCache.availableIMXReward;
-  }
-  private async initializeAvailableRewarderReward() : Promise<number> {
-    if (!await this.poolToken.hasRewarder()) return 0;
-    const borrowableAddress = await this.poolToken.getPoolTokenAddress();
-    const rewarder  = await this.poolToken.getRewarder();
-    try {
-      return await rewarder.methods.pendingReward(borrowableAddress, this.getAccount()).call() / 1e18;
-    } catch {
-      console.log("Warning: pending reward negative");
-      return 0;
-    }
-  }
-  async getAvailableRewarderReward() {
-    if (!this.borrowableCache.availableRewarderReward) this.borrowableCache.availableRewarderReward = this.initializeAvailableRewarderReward();
-    return this.borrowableCache.availableRewarderReward;
-  }
-
-}

package/impermax-router/AccountCollateral.ts

@@ -1,40 +0,0 @@
-import { NO_CHANGES } from "./interfaces";
-import AccountPoolToken from "./AccountPoolToken";
-import Collateral from "./Collateral";
-
-export default class AccountCollateral extends AccountPoolToken {
-  poolToken: Collateral;
-  collateralCache: {
-  } = {};
-
-  cleanCache() {
-    super.cleanCache();
-    this.collateralCache = {};
-  }
-
-  async fixStakedLPExchangeRate(n: Promise<number>) : Promise<number> {
-    const stakedLPExchangeRate = await this.poolToken.lendingPool.getStakedLPExchangeRate();
-    return await n / stakedLPExchangeRate;
-  }
-
-  async getAvailableBalanceUSD() : Promise<number> {
-    return this.fixStakedLPExchangeRate(super.getAvailableBalanceUSD());
-  }
-
-  async getDepositedUSD() : Promise<number> {
-    return this.fixStakedLPExchangeRate(super.getDepositedUSD());
-  }
-
-  // Max Withdrawable
-  async getMaxWithdrawable() : Promise<number> {
-    const deposited = await this.getDeposited();
-    const availableCash = await this.poolToken.getTotalBalance();
-    const { valueCollateral, valueA, valueB } = await this.accountLendingPool.getValues(NO_CHANGES);
-    const safetyMargin = (await this.accountLendingPool.getSafetyMargin()) * this.getUiMargin();
-    const liquidationPenalty = await this.accountLendingPool.getLiquidationPenalty();
-    const actualCollateral = valueCollateral / liquidationPenalty;
-    const maxWithdrawable1 = (actualCollateral - (valueA + valueB * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty;
-    const maxWithdrawable2 = (actualCollateral - (valueB + valueA * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty;
-    return Math.max(0, Math.min(deposited, availableCash, maxWithdrawable1, maxWithdrawable2) / this.getDust());
-  }
-}

package/impermax-router/AccountLendingPool.ts

@@ -1,231 +0,0 @@
-import { Changes, NO_CHANGES, PendingRewardUI, Values } from "./interfaces";
-import Account from "./Account";
-import AccountBorrowable from "./AccountBorrowable";
-import AccountCollateral from "./AccountCollateral";
-
-import LendingPool from "./LendingPool";
-import { PoolTokenType } from '../config/types';
-
-export default class AccountLendingPool {
-  account: Account;
-  lendingPool: LendingPool;
-  accountPoolTokens: {
-    [PoolTokenType.Collateral]: AccountCollateral,
-    [PoolTokenType.BorrowableA]: AccountBorrowable,
-    [PoolTokenType.BorrowableB]: AccountBorrowable,
-  }
-  cache: {
-    availableReward?: Promise<PendingRewardUI[]>,
-    oldAvailableReward?: Promise<number>,
-  } = {};
-
-  constructor(account: Account, lendingPool: LendingPool) {
-    this.account = account;
-    this.lendingPool = lendingPool;
-    this.accountPoolTokens = {
-      [PoolTokenType.Collateral]: new AccountCollateral(this, PoolTokenType.Collateral),
-      [PoolTokenType.BorrowableA]: new AccountBorrowable(this, PoolTokenType.BorrowableA),
-      [PoolTokenType.BorrowableB]: new AccountBorrowable(this, PoolTokenType.BorrowableB),
-    };
-  }
-
-  cleanCache() {
-    this.cache = {};
-    this.pta().cleanCache();
-    this.ptb().cleanCache();
-    this.ptc().cleanCache();
-  }
-
-  // Shortcuts
-  pta = () => this.accountPoolTokens[PoolTokenType.BorrowableA];
-  ptb = () => this.accountPoolTokens[PoolTokenType.BorrowableB];
-  ptc = () => this.accountPoolTokens[PoolTokenType.Collateral];
-  getSafetyMargin = async () => (await this.lendingPool.getSubgraphLendingPool()).getSafetyMargin();
-  getLiquidationPenalty = async () => (await this.lendingPool.getSubgraphLendingPool()).getLiquidationPenalty();
-  getUiMargin = () => this.account.router.uiMargin;
-  
-  // Balance
-  async getBalanceUSD() : Promise<number> {
-    const depositedAUSD = await this.pta().getDepositedUSD();
-    const depositedBUSD = await this.ptb().getDepositedUSD();
-    const depositedCUSD = await this.ptc().getDepositedUSD();
-    return depositedAUSD + depositedBUSD + depositedCUSD;
-  }
-
-  // Supplied
-  async getSuppliedUSD() : Promise<number> {
-    const depositedAUSD = await this.pta().getDepositedUSD();
-    const depositedBUSD = await this.ptb().getDepositedUSD();
-    return depositedAUSD + depositedBUSD;
-  }
-
-  // Debt
-  async getDebtUSD() : Promise<number> {
-    const borrowedAUSD = await this.pta().getBorrowedUSD();
-    const borrowedBUSD = await this.ptb().getBorrowedUSD();
-    return borrowedAUSD + borrowedBUSD;
-  }
-
-  // Equity
-  async getEquityUSD() : Promise<number> {
-    const balanceUSD = await this.getBalanceUSD();
-    const debtUSD = await this.getDebtUSD();
-    return balanceUSD - debtUSD;
-  }
-  async getLPEquityUSD() : Promise<number> {
-    const collateralUSD = await this.ptc().getDepositedUSD();
-    const debtUSD = await this.getDebtUSD();
-    return collateralUSD - debtUSD;
-  }
-  async getLPEquity() : Promise<number> {
-    const lpEquityUSD = await this.getLPEquityUSD();
-    const tokenPrice = await this.ptc().getTokenPriceAccurate();
-    const stakedLPExchangeRate = await this.lendingPool.getStakedLPExchangeRate();
-    return lpEquityUSD / tokenPrice * stakedLPExchangeRate;
-  }
-  
-  // Debt
-  async getAccountAPR() : Promise<number> {
-    const depositedAUSD = await this.pta().getDepositedUSD();
-    const depositedBUSD = await this.ptb().getDepositedUSD();
-    const totalSupplied = depositedAUSD + depositedBUSD;
-    const supplyAPRA = await this.pta().getSupplyAPR();
-    const supplyAPRB = await this.ptb().getSupplyAPR();
-    return totalSupplied > 0 ? (depositedAUSD * supplyAPRA + depositedBUSD * supplyAPRB) / totalSupplied : 0;
-  }
-
-  // Values
-  async getValuesFromPrice(changes: Changes, priceA: number, priceB: number) {
-    const valueCollateral = await this.ptc().getDeposited() + changes.changeCollateral;
-    const amountA = await this.pta().getBorrowed() + changes.changeBorrowedA;
-    const amountB = await this.ptb().getBorrowed() + changes.changeBorrowedB;
-    const valueA = amountA * priceA;
-    const valueB = amountB * priceB;
-    return {
-      valueCollateral: valueCollateral > 0 ? valueCollateral : 0, 
-      valueA: valueA > 0 ? valueA : 0, 
-      valueB: valueB > 0 ? valueB : 0,
-    };
-  }
-  async getValues(changes: Changes) {
-    const [priceA, priceB] = await this.lendingPool.getPriceDenomLP();
-    return this.getValuesFromPrice(changes, priceA, priceB);
-  }
-  async getMarketValues(changes: Changes) {
-    const [priceA, priceB] = await this.lendingPool.getMarketPriceDenomLP();  
-    return this.getValuesFromPrice(changes, priceA, priceB);
-  }
-  
-  // Leverage
-  async getLeverage(changes?: Changes) : Promise<number> {
-    if (!changes) changes = NO_CHANGES;
-    const { valueCollateral, valueA, valueB } = await this.getValues(changes);
-    const valueDebt = valueA + valueB;
-    if (valueDebt == 0) return 1;
-    const equity = valueCollateral - valueDebt;
-    if (equity <= 0) return Infinity;
-    return valueDebt / equity + 1;
-  }
-
-  // Liquidation Threshold
-  async getLiquidationPriceSwingsGivenValues(values: Values) : Promise<[number, number]> {
-    if (!values) return [Infinity, Infinity];
-    const { valueCollateral, valueA, valueB } = values;
-    if (valueA + valueB == 0) return [Infinity, Infinity];
-    const safetyMargin = await this.getSafetyMargin();
-    const liquidationPenalty = await this.getLiquidationPenalty();
-    const actualCollateral = valueCollateral / liquidationPenalty;
-    const rad = Math.sqrt(actualCollateral ** 2 - 4 * valueA * valueB);
-    if (!rad) return [0, 0];
-    const t = (actualCollateral + rad) / (2 * Math.sqrt(safetyMargin));
-    let priceSwingA = (t / valueA) ** 2;
-    let priceSwingB = (t / valueB) ** 2;
-    return [priceSwingA, priceSwingB];
-  }
-  async getLiquidationPricesGivenValues(values: Values) : Promise<[number, number]> {
-    const currentPrice = await this.lendingPool.getTWAPPrice();
-    const [priceSwingA, priceSwingB] = await this.getLiquidationPriceSwingsGivenValues(values);
-    return !this.account.router.priceInverted ? [currentPrice / priceSwingB, currentPrice * priceSwingA] : [currentPrice / priceSwingA, currentPrice * priceSwingB];
-  }
-  async getLiquidationPriceSwings(changes?: Changes) {
-    const values = await this.getValues(changes);
-    return this.getLiquidationPriceSwingsGivenValues(values);
-  }
-  async getLiquidationPrices(changes?: Changes) {
-    if (!changes) changes = NO_CHANGES;
-    const values = await this.getValues(changes);
-    return this.getLiquidationPricesGivenValues(values);
-  }
-
-  // Max Leverage
-  async getMaxLeverage() : Promise<number> {
-    const availableCashA = await this.pta().poolToken.getTotalBalance();
-    const availableCashB = await this.ptb().poolToken.getTotalBalance();
-    const [priceA, priceB] = await this.lendingPool.getMarketPriceDenomLP();
-    const [priceATWAP,] = await this.lendingPool.getPriceDenomLP();
-    const diff = priceA > priceATWAP ? priceA / priceATWAP : priceATWAP / priceA;
-    const adjustFactor = 1 / diff;
-    const availableCashValue1 = availableCashA * priceA;
-    const availableCashValue2 = availableCashB * priceB;
-    const { valueCollateral, valueA, valueB } = await this.getValues(NO_CHANGES);
-    const safetyMargin = (await this.getSafetyMargin()) * this.getUiMargin();
-    const liquidationPenalty = await this.getLiquidationPenalty();
-    const actualCollateral = valueCollateral / liquidationPenalty;
-    const num1 = actualCollateral * Math.sqrt(safetyMargin) - valueA * safetyMargin - valueB;
-    const num2 = actualCollateral * Math.sqrt(safetyMargin) - valueB * safetyMargin - valueA;
-    const den = safetyMargin + 1 - 2 * Math.sqrt(safetyMargin) / liquidationPenalty;
-    const additionalValueBorrowablePerSide = Math.min(num1 / den, num2 / den, availableCashValue1, availableCashValue2) * adjustFactor;
-    const valueDebt = valueA + valueB;
-    const equity = valueCollateral - valueDebt;
-    if (equity == 0) return 1;
-    return (valueDebt + additionalValueBorrowablePerSide * 2) / equity + 1;
-  }
-
-  // Max Deleverage
-  async getMaxDeleverage(slippage: number) : Promise<number> {
-    const { valueCollateral, valueA, valueB } = await this.getMarketValues(NO_CHANGES);
-    const minRepayPerSide = valueCollateral / 2 / Math.sqrt(slippage);
-    if ( minRepayPerSide >= valueA && minRepayPerSide >= valueB ) {
-      return this.ptc().getDeposited();
-    }
-    if ( minRepayPerSide * 2 < valueA + valueB ) {
-      return 0;
-    }
-    return Math.min(valueA, valueB) * 2 * Math.sqrt(slippage);
-  }
-  
-  // Available Reward
-  async getAvailableReward() : Promise<PendingRewardUI[]> {
-    const result = [];
-    const imxAmount = await this.pta().getAvailableIMXReward() + await this.ptb().getAvailableIMXReward();
-    if (imxAmount > 0) result.push({
-      symbol: "IMX",
-      amount: imxAmount
-    });
-    const symbols = [
-      await this.pta().poolToken.getRewarderTokenSymbol(),
-      await this.ptb().poolToken.getRewarderTokenSymbol()
-    ];
-    const rewarderAmounts = [
-      await this.pta().getAvailableRewarderReward(),
-      await this.ptb().getAvailableRewarderReward()
-    ];
-    if (symbols[0] === symbols[1]) {
-      const rewarderAmount = rewarderAmounts[0] + rewarderAmounts[1];
-      if (rewarderAmount === 0) return result;
-      result.push({
-        symbol: symbols[0],
-        amount: rewarderAmount
-      }) 
-    } else {
-      for (let i = 0; i < 2; i++) {
-        if (rewarderAmounts[i] === 0) continue;
-        result.push({
-          symbol: symbols[i],
-          amount: rewarderAmounts[i]
-        })
-      }
-    }
-    return result;
-  }
-}

package/impermax-router/AccountPoolToken.ts

@@ -1,76 +0,0 @@
-import AccountLendingPool from "./AccountLendingPool";
-import PoolToken from "./PoolToken";
-import { PoolTokenType } from '../config/types';
-import { WETH } from '../config/contracts/weths';
-
-export default class AccountPoolToken {
-  accountLendingPool: AccountLendingPool;
-  poolToken: PoolToken;
-  cache: {
-    availableBalance?: Promise<number>,
-    deposited?: Promise<number>,
-  } = {};
-
-  constructor(accountLendingPool: AccountLendingPool, poolTokenType: PoolTokenType) {
-    this.accountLendingPool = accountLendingPool;
-    this.poolToken = accountLendingPool.lendingPool.poolTokens[poolTokenType];
-  }
-
-  cleanCache() {
-    this.cache = {};
-  }
-
-  // Shortcuts
-  getAccount = () => this.accountLendingPool.account.account;
-  getNetwrok = () => this.accountLendingPool.account.router.network;
-  getEth = () => this.accountLendingPool.account.router.web3.eth;
-  getDust = () => this.accountLendingPool.account.router.dust;
-  getUiMargin = () => this.accountLendingPool.account.router.uiMargin;
-  getTokenPriceAccurate = async () => (await this.poolToken.getSubgraphPoolToken()).getTokenPriceAccurate();
-  getSupplyAPR = async () => (await this.poolToken.getSubgraphPoolToken()).getSupplyAPR();
-  getBorrowRate = async () => (await this.poolToken.getSubgraphPoolToken()).getBorrowRate();
-  getAccrualTimestamp = async () => (await this.poolToken.getSubgraphPoolToken()).getAccrualTimestamp();
-
-  // Available Balance
-  private async initializeAvailableBalance() : Promise<number> {
-    const token = await this.poolToken.getToken();
-    if (token._address.toLowerCase() == WETH[this.getNetwrok()].toLowerCase()) {
-      return (await this.getEth().getBalance(this.getAccount())) / 1e18 / this.getDust();
-    }
-    const balance = await token.methods.balanceOf(this.getAccount()).call();
-    return (await this.poolToken.normalize(balance)) / this.getDust();
-  }
-  async getAvailableBalance() : Promise<number> {
-    if (!this.cache.availableBalance) this.cache.availableBalance = this.initializeAvailableBalance();
-    return this.cache.availableBalance;
-  }
-  async getAvailableBalanceUSD() : Promise<number> {
-    const availableBalance = await this.getAvailableBalance();
-    const tokenPrice = await this.getTokenPriceAccurate();
-    return availableBalance * tokenPrice;
-  }
-
-  // Deposited
-  private async initializeDeposited() : Promise<number> {
-    const poolToken = await this.poolToken.getPoolToken();
-    const exchangeRate = await this.poolToken.getExchangeRate();
-    const balance = await poolToken.methods.balanceOf(this.getAccount()).call();
-    return (await this.poolToken.normalize(balance)) * exchangeRate;
-  }
-  async getDeposited() : Promise<number> {
-    if (!this.cache.deposited) this.cache.deposited = this.initializeDeposited();
-    return this.cache.deposited;
-  }
-  async getDepositedUSD() : Promise<number> {
-    const deposited = await this.getDeposited();
-    const tokenPrice = await this.getTokenPriceAccurate();
-    return deposited * tokenPrice;
-  }
-
-  // Max Withdrawable
-  async getMaxWithdrawable() : Promise<number> {
-    const deposited = await this.getDeposited();
-    const availableCash = await this.poolToken.getTotalBalance();
-    return Math.min(deposited, availableCash) / this.getDust();
-  }
-}