impermax-sdk 1.0.0

package/config/types.ts

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

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

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

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

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

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