impermax-sdk 1.0.1 → 1.0.2

package/impermax-router/LendingPool.ts

@@ -1,256 +0,0 @@
-import { PendingRewardUI } from "./interfaces";
-
-import PoolToken from "./PoolToken";
-import ImpermaxFactory from "./ImpermaxFactory";
-import { Contract } from "ethers";
-import Collateral from "./Collateral";
-import Borrowable from "./Borrowable";
-import { Address, PoolTokenType } from '../config/types';
-import { SOLIDEX_FACTORIES } from '../config/factories';
-
-export default class LendingPool {
-  factory: ImpermaxFactory;
-  pairAddress: Address;
-  poolTokens: {
-    [PoolTokenType.Collateral]: Collateral,
-    [PoolTokenType.BorrowableA]: Borrowable,
-    [PoolTokenType.BorrowableB]: Borrowable,
-  };
-  cache: {
-    poolTokenAddresses?: Promise<{
-      [key in PoolTokenType]: Address
-    }>
-    isStakedLPToken?: Promise<boolean>,
-    uniswapV2Pair?: Promise<Contract>, // native uniswap pair
-    stakedLPToken?: Promise<Contract>, // collateral underlying
-    reserves?: Promise<[number, number]>,
-    LPTotalSupply?: Promise<number>,
-    marketPrice?: Promise<number>,
-    priceDenomLP?: Promise<[number, number]>,
-    TWAPPrice?: Promise<number>,
-    pendingReward?: Promise<PendingRewardUI>,
-    reinvestBountyFactor?: Promise<number>,
-    stakedLPExchangeRate?: Promise<number>,
-  } = {};
-
-  constructor(factory: ImpermaxFactory, pairAddress: Address) {
-    this.factory = factory;
-    this.pairAddress = pairAddress;
-    this.poolTokens = {
-      [PoolTokenType.Collateral]: new Collateral(this, PoolTokenType.Collateral),
-      [PoolTokenType.BorrowableA]: new Borrowable(this, PoolTokenType.BorrowableA),
-      [PoolTokenType.BorrowableB]: new Borrowable(this, PoolTokenType.BorrowableB),
-    };
-  }
-
-  cleanCache() {
-    this.cache = {};
-    this.pta().cleanCache();
-    this.ptb().cleanCache();
-    this.ptc().cleanCache();
-  }
-
-  // Shortcuts
-  pta = () => this.poolTokens[PoolTokenType.BorrowableA];
-  ptb = () => this.poolTokens[PoolTokenType.BorrowableB];
-  ptc = () => this.poolTokens[PoolTokenType.Collateral];
-
-  getPoolToken(poolTokenType: PoolTokenType) : PoolToken {
-    return this.poolTokens[poolTokenType];
-  }
-
-  async getSubgraphLendingPool() {
-    return this.factory.router.subgraph.getLendingPool(this.factory.factory, this.pairAddress);
-  }
-
-  private async initializePoolTokenAddresses() {
-    const lPool = await this.factory.getRouter().methods.getLendingPool(this.pairAddress).call();
-    return {
-      [PoolTokenType.Collateral]: lPool.collateral as Address,
-      [PoolTokenType.BorrowableA]: lPool.borrowableA as Address,
-      [PoolTokenType.BorrowableB]: lPool.borrowableB as Address,
-    }
-  }
-  async getPoolTokenAddresses() {
-    if (!this.cache.poolTokenAddresses) this.cache.poolTokenAddresses = this.initializePoolTokenAddresses();
-    return this.cache.poolTokenAddresses;
-  }
-
-  private async initializeIsStakedLPToken() : Promise<boolean> {
-    try {
-      return await this.factory.getRouter().methods.isStakedLPToken(this.pairAddress).call();
-    } catch (e) {
-      return false;
-    }
-  }
-  async getIsStakedLPToken() {
-    if (!this.cache.isStakedLPToken) this.cache.isStakedLPToken = this.initializeIsStakedLPToken();
-    return this.cache.isStakedLPToken;
-  }
-
-  private async initializeStakedLPToken() : Promise<Contract> {
-    if (!await this.getIsStakedLPToken()) return null;
-    return this.factory.router.contractsHelper.newStakedLPToken(this.pairAddress);
-  }
-  async getStakedLPToken() {
-    if (!this.cache.stakedLPToken) this.cache.stakedLPToken = this.initializeStakedLPToken();
-    return this.cache.stakedLPToken;
-  }
-
-  private async initializeUniswapV2Pair() : Promise<Contract> {
-    return this.factory.router.contractsHelper.newUniswapV2Pair(
-      await this.getIsStakedLPToken() 
-        ? await (await this.getStakedLPToken()).methods.underlying().call()
-        : this.pairAddress
-    );
-  }
-  async getUniswapV2Pair() {
-    if (!this.cache.uniswapV2Pair) this.cache.uniswapV2Pair = this.initializeUniswapV2Pair();
-    return this.cache.uniswapV2Pair;
-  }
-
-  // Reserves
-  private async initializeReserves() : Promise<[number, number]> {
-    const uniswapV2Pair = await this.getUniswapV2Pair();
-    const { reserve0, reserve1 } = await uniswapV2Pair.methods.getReserves().call();
-    return [
-      await this.pta().normalize(reserve0),
-      await this.ptb().normalize(reserve1),
-    ];
-  }
-  async getReserves() {
-    if (!this.cache.reserves) this.cache.reserves = this.initializeReserves();
-    return this.cache.reserves;
-  }
-
-  // LP Total Supply
-  private async initializeLPTotalSupply() {
-    const uniswapV2Pair = await this.getUniswapV2Pair();
-    const totalSupply = await uniswapV2Pair.methods.totalSupply().call();
-    return this.ptc().normalize(totalSupply);
-  }
-  async getLPTotalSupply() : Promise<number> {
-    if (!this.cache.LPTotalSupply) this.cache.LPTotalSupply = this.initializeLPTotalSupply();
-    return this.cache.LPTotalSupply;
-  }
-
-  // Price Denom LP
-  private async initializePriceDenomLP() : Promise<[number, number]> {
-    const collateral = await this.ptc().getPoolToken();
-    const { price0, price1 } = await collateral.methods.getPrices().call();
-    const decimalsA = await this.pta().getDecimals();
-    const decimalsB = await this.ptb().getDecimals();
-    let stakedLPExchangeRate = await this.getStakedLPExchangeRate();
-    return [
-      price0 / 1e18 / 1e18 * Math.pow(10, decimalsA) * stakedLPExchangeRate,
-      price1 / 1e18 / 1e18 * Math.pow(10, decimalsB) * stakedLPExchangeRate
-    ];
-  }
-  async getPriceDenomLP() {
-    if (!this.cache.priceDenomLP) this.cache.priceDenomLP = this.initializePriceDenomLP();
-    return this.cache.priceDenomLP;
-  }
-  async getMarketPriceDenomLP() : Promise<[number, number]> {
-    const [reserve0, reserve1] = await this.getReserves();
-    const totalSupply = await this.getLPTotalSupply();
-    return [
-      totalSupply / reserve0 / 2,
-      totalSupply / reserve1 / 2,
-    ];
-  }
-
-  // Market Price
-  async getMarketPrice() : Promise<number> {
-    const [reserve0, reserve1] = await this.getReserves();
-    return this.factory.router.priceInverted ? 1 * reserve0 / reserve1 : 1 * reserve1 / reserve0;
-  }
-  
-  // TWAP Price
-  private async initializeTWAPPrice() : Promise<number> {
-    try {
-      let price;
-      if (SOLIDEX_FACTORIES.includes(this.factory.factory)) {
-        const collateral = await this.ptc().getPoolToken();
-        price = await collateral.methods.getTwapPrice112x112().call();
-      } else {
-        price = (await this.factory.getSimpleUniswapOracle().methods.getResult(this.pairAddress).call()).price;
-      }
-      const decimalsA = await this.pta().getDecimals();
-      const decimalsB = await this.ptb().getDecimals();
-      return price / 2**112 * Math.pow(10, decimalsA) / Math.pow(10, decimalsB);
-    }
-    catch (e) {
-      // Oracle is not initialized yet
-      return 0;
-    }
-  }
-  async getTWAPPrice() : Promise<number> {
-    if (!this.cache.TWAPPrice) this.cache.TWAPPrice = this.initializeTWAPPrice();
-    return !this.factory.router.priceInverted ? (await this.cache.TWAPPrice) :  1 / (await this.cache.TWAPPrice);
-  }
-
-  // Exchange rate
-  private async initializeStakedLPExchangeRate() : Promise<number> {
-    if (!await this.getIsStakedLPToken()) return 1;
-    const stakedLPToken = await this.getStakedLPToken();
-    return await stakedLPToken.methods.exchangeRate().call() / 1e18;
-  }
-  async getStakedLPExchangeRate() : Promise<number> {
-    if (!this.cache.stakedLPExchangeRate) this.cache.stakedLPExchangeRate = this.initializeStakedLPExchangeRate();
-    return this.cache.stakedLPExchangeRate;
-  }
-
-  // Pending Reward
-  private async initializePendingReward() : Promise<PendingRewardUI> {
-    const stakedLPToken = await this.getStakedLPToken();
-    const rewardTokenAddress = await stakedLPToken.methods.rewardsToken().call();
-    const rewardToken = this.factory.router.contractsHelper.newERC20(rewardTokenAddress);
-    const decimals = await rewardToken.methods.decimals().call();
-    let result = {
-      amount: 0,
-      symbol: await rewardToken.methods.symbol().call(),
-    }
-    try {    
-      const pendingReward = await stakedLPToken.methods.getReward().call();
-      result.amount = pendingReward / Math.pow(10, decimals);
-    }
-    catch {
-      try {
-        const stakingRewardsAddress = await stakedLPToken.methods.stakingRewards().call();
-        const stakingRewards = this.factory.router.contractsHelper.newStakingRewards(stakingRewardsAddress);
-        const earned = await stakingRewards.methods.earned(stakedLPToken._address).call();
-        result.amount = earned / Math.pow(10, decimals);
-      }
-      catch {}
-    }
-    return result;
-  }
-  async getPendingReward() : Promise<PendingRewardUI> {
-    if (!this.cache.pendingReward) this.cache.pendingReward = this.initializePendingReward();
-    return this.cache.pendingReward;
-  }
-
-  // Reinvest Bounty Factor
-  private async initializeReinvestBountyFactor() : Promise<number> {
-    if (!await this.getIsStakedLPToken()) return 0;
-    const stakedLPToken = await this.getStakedLPToken();
-    return (await stakedLPToken.methods.REINVEST_BOUNTY().call()) / 1e18;
-  }
-  async getReinvestBountyFactor() : Promise<number> {
-    if (!this.cache.reinvestBountyFactor) this.cache.reinvestBountyFactor = this.initializeReinvestBountyFactor();
-    return this.cache.reinvestBountyFactor;
-  }
-
-  // Reinvest Bounty
-  async getReinvestBounty() : Promise<number> {
-    const pendingReward = await this.getPendingReward();
-    const reinvestBountyFactor = await this.getReinvestBountyFactor();
-    return pendingReward.amount * reinvestBountyFactor;
-  }
-
-  // Has Farming
-  async hasFarming() : Promise<boolean> {
-    return await this.pta().hasFarming() || await this.ptb().hasFarming();
-  }
-
-}

package/impermax-router/PoolToken.ts

@@ -1,112 +0,0 @@
-import { BigNumber } from "ethers";
-import { Contract } from "./interfaces";
-import { isValidNumber } from "../utils";
-import { decimalToBalance } from "../utils/ether-utils";
-import LendingPool from "./LendingPool";
-import { Address, PoolTokenType } from '../config/types';
-
-export default abstract class PoolToken {
-  lendingPool: LendingPool;
-  poolTokenType: PoolTokenType;
-  cache: {
-    token?: Promise<Contract>,
-    poolToken?: Promise<Contract>,
-    exchangeRate?: Promise<number>,
-    totalBalance?: Promise<number>,
-  } = {};
-
-  constructor(lendingPool: LendingPool, poolTokenType: PoolTokenType) {
-    this.lendingPool = lendingPool;
-    this.poolTokenType = poolTokenType;
-  }
-
-  cleanCache() {
-    this.cache = {}
-  }
-
-  getContractHelper = () => this.lendingPool.factory.router.contractsHelper;
-
-  async getSubgraphPoolToken() {
-    const lendingPool = await this.lendingPool.getSubgraphLendingPool();
-    return lendingPool.poolTokens[this.poolTokenType];
-  }
-
-  protected async getPoolTokenAddressFromLendingPool() {
-    return (await this.lendingPool.getPoolTokenAddresses())[this.poolTokenType];
-  }
-  abstract initializePoolToken() : Promise<Contract>;
-  async getPoolToken() {
-    if (!this.cache.poolToken) this.cache.poolToken = this.initializePoolToken();
-    return this.cache.poolToken;
-  }
-  async getPoolTokenAddress() : Promise<Address> {
-    return (await this.getPoolToken())._address;
-  }
-
-  abstract initializeToken() : Promise<Contract>;
-  async getToken() {
-    if (!this.cache.token) this.cache.token = this.initializeToken();
-    return this.cache.token;
-  }
-  async getTokenAddress() {
-    return (await this.getToken())._address;
-  }
-
-  async getDecimals() {
-    const subgraph = await this.getSubgraphPoolToken();
-    return await subgraph.getDecimals();
-  }
-
-  // Utilities
-  async normalize(amount: number) : Promise<number> {
-    return amount / Math.pow(10, await this.getDecimals());
-  }
-  async toBigNumber(amount: number) : Promise<BigNumber> {
-    if (!isValidNumber(amount)) return null;
-    return decimalToBalance(amount, await this.getDecimals());
-  }
-  async toNumber(amount: BigNumber) : Promise<number> {
-    if (!amount) return null;
-    return parseFloat(amount.toString()) / Math.pow(10, await this.getDecimals());
-  }
-  async toTokens(amount: number) : Promise<BigNumber> {
-    if (!isValidNumber(amount)) return null;
-    const exchangeRate = await this.getExchangeRate();
-    return decimalToBalance(amount / exchangeRate, await this.getDecimals());
-  }
-  async fromTokens(amount: BigNumber) : Promise<number> {
-    if (!amount) return null;
-    const exchangeRate = await this.getExchangeRate();
-    return parseFloat(amount.toString()) * exchangeRate / Math.pow(10, await this.getDecimals());
-  }
-
-  // Total balance
-  private async initializeTotalBalance() {
-    const poolToken = await this.getPoolToken();
-    const amount = await poolToken.methods.totalBalance().call();
-    return this.normalize(amount);
-  }
-  async getTotalBalance() {
-    if (!this.cache.totalBalance) this.cache.totalBalance = this.initializeTotalBalance();
-    return this.cache.totalBalance;
-  }
-  async getTotalBalanceUSD() {
-    const totalBalance = await this.getTotalBalance();
-    const subgraph = await this.getSubgraphPoolToken();
-    const tokenPrice = await subgraph.getTokenPriceFast();
-    return totalBalance * tokenPrice;
-  }
-
-  // Exchange rate
-  protected async initializeExchangeRate() : Promise<number> {
-    const poolToken = await this.getPoolToken();
-    let exchangeRate = await poolToken.methods.exchangeRate().call() / 1e18;
-    return exchangeRate;
-  }
-  async getExchangeRate() : Promise<number> {
-    if (!this.cache.exchangeRate) this.cache.exchangeRate = this.initializeExchangeRate();
-    return this.cache.exchangeRate;
-  }
-
-
-}

package/impermax-router/index.ts

@@ -1,49 +0,0 @@
-import {
-  ImpermaxRouterCfg
-} from "./interfaces";
-import Subgraph from "../subgraph";
-import ContractsHelper from "./ContractsHelper";
-import ImpermaxFactory from "./ImpermaxFactory";
-import { Factory, FactoryIndex, Networks } from '../config/types';
-
-export default class ImpermaxRouter {
-  network: Networks;
-  subgraph: Subgraph;
-  web3: any;
-  chainId: number;
-
-  contractsHelper: ContractsHelper;
-  factories: FactoryIndex<ImpermaxFactory>;
-
-  uiMargin: number;
-  dust: number;
-  priceInverted: boolean;
-
-  constructor(cfg: ImpermaxRouterCfg) {
-    this.network = cfg.network;
-    this.subgraph = cfg.subgraph;
-    this.web3 = cfg.web3;
-    this.chainId = cfg.chainId;
-    this.uiMargin = 1.1;
-    this.dust = 1.000001;
-    this.priceInverted = cfg.priceInverted;
-
-    this.contractsHelper = new ContractsHelper(this);
-    this.factories = {};
-  }
-
-  cleanCache() {
-    for (const factory of Object.keys(this.factories) as Factory[]) {
-      this.factories[factory].cleanCache();
-    }
-  }
-
-  setPriceInverted(priceInverted: boolean) {
-    this.priceInverted = priceInverted;
-  }
-
-  getFactory(factory: Factory) {
-    if (!this.factories[factory]) this.factories[factory] = new ImpermaxFactory(this, factory);
-    return this.factories[factory];
-  }
-}

package/impermax-router/interfaces.ts

@@ -1,233 +0,0 @@
-import { BigNumber } from "ethers";
-import Subgraph from "../subgraph";
-import { Address, Networks, PoolTokenType } from '../config/types';
-
-export type Contract = any;
-export type RouterContract = Contract;
-export type FactoryContract = Contract;
-export type SimpleUniswapOracleContract = Contract;
-export type ERC20Contract = Contract;
-export type UniswapV2PairContract = Contract;
-export type UniswapV2FactoryContract = Contract;
-export type BorrowableContract = Contract;
-export type CollateralContract = Contract;
-export type MerkleDistributorContract = Contract;
-export type FarmingPoolContract = Contract;
-export type ClaimAggregatorContract = Contract;
-export type ClaimableContract = Contract;
-export type StakedLPTokenContract = Contract;
-export type ImpermaxChefContract = Contract;
-
-export type LendingPool = {
-  uniswapV2Pair: UniswapV2PairContract,
-  tokenA: ERC20Contract,
-  tokenB: ERC20Contract,
-  collateral: CollateralContract,
-  borrowableA: BorrowableContract,
-  borrowableB: BorrowableContract,
-  farmingPoolA: FarmingPoolContract,
-  farmingPoolB: FarmingPoolContract,
-  stakedLPToken: StakedLPTokenContract,
-}
-
-export enum ApprovalType {
-  POOL_TOKEN,
-  UNDERLYING,
-  BORROW,
-}
-
-export interface PermitData {
-  permitData: string;
-  amount: BigNumber;
-  deadline: BigNumber;
-}
-
-export interface Changes {
-  changeBorrowedA: number;
-  changeBorrowedB: number;
-  changeCollateral: number;
-}
-export const NO_CHANGES = {
-  changeBorrowedA: 0,
-  changeBorrowedB: 0,
-  changeCollateral: 0,
-}
-export interface Values {
-  valueCollateral: number;
-  valueA: number;
-  valueB: number;
-}
-
-export interface ImpermaxRouterCfg {
-  network: Networks;
-  subgraph: Subgraph;
-  web3: any;
-  chainId: number;
-  priceInverted: boolean;
-}
-
-export interface PoolTokenData {
-  id: Address,
-  totalBalance: string,
-  exchangeRate: string,
-  totalBalanceUSD: string,
-}
-
-export interface BorrowableData extends PoolTokenData {
-  underlying: TokenData,
-  totalBorrows: string,
-  borrowRate: string,
-  reserveFactor: string,
-  kinkBorrowRate: string,
-  kinkUtilizationRate: string,
-  borrowIndex: string,
-  accrualTimestamp: string,
-  farmingPool: FarmingPoolData,
-  rewards?: Array<{
-    rewardToken: Address, 
-    rewardRate: number
-  }>,
-}
-
-export interface CollateralData extends PoolTokenData {
-  safetyMargin: string,
-  liquidationIncentive: string,
-  liquidationFee: string,
-}
-
-export interface BorrowablePastData {
-  borrowIndex: string,
-  accrualTimestamp: string,
-  exchangeRate: string,
-}
-
-export interface TokenData {
-  id: Address,
-  symbol: string,
-  name: string,
-  decimals: string,
-  derivedUSD: string,
-}
-
-export interface RewardData {
-  id: Address,
-  rewardRate: string,
-  rewardsToken: TokenData,
-  periodFinish: string,
-}
-
-export interface PairData {
-  id: Address,
-  factory: string,
-  reserve0: string,
-  reserve1: string,
-  totalSupply: string,
-  reserveUSD: string,
-  token0Price: string,
-  token1Price: string,
-  derivedUSD: string,
-  uniswapV2PairAddress: string,
-  uniswapV2Factory: string,
-  isStakedLPToken: boolean,
-  exchangeRate: string,
-  stakingRewards: string,
-  masterChef: string,
-  pid: string,
-  stakedTotalSupply: string,
-  rewards: Array<RewardData>,
-  uniswapAPR: number,
-}
-
-export interface FarmingPoolData {
-  epochAmount: string,
-  epochBegin: string,
-  segmentLength: string,
-  vestingBegin: string,
-  sharePercentage: string,
-}
-
-export interface LendingPoolPastData {
-  [PoolTokenType.Collateral]: undefined,
-  [PoolTokenType.BorrowableA]: BorrowablePastData,
-  [PoolTokenType.BorrowableB]: BorrowablePastData,
-}
-
-export interface LendingPoolData {
-  id: Address,
-  [PoolTokenType.Collateral]: CollateralData,
-  [PoolTokenType.BorrowableA]: BorrowableData,
-  [PoolTokenType.BorrowableB]: BorrowableData,
-  pair: PairData,
-  past24h?: LendingPoolPastData,
-  past7d?: LendingPoolPastData,
-}
-
-export interface CollateralPosition {
-  balance: string,
-  collateral: {
-    lendingPool: {
-      id: Address,
-    }
-  }
-}
-
-export interface SupplyPosition {
-  balance: string,
-  borrowable: {
-    underlying: {
-      id: Address
-    },
-    lendingPool: {
-      id: Address,
-    }
-  }
-}
-
-export interface BorrowPosition {
-  borrowBalance: string,
-  borrowIndex: string,
-  borrowable: {
-    underlying: {
-      id: Address
-    },
-    lendingPool: {
-      id: Address,
-    }
-  }
-}
-
-export interface UserData {
-  collateralPositions: { [key in Address]: CollateralPosition },
-  supplyPositions: { [key in Address]: { [key in PoolTokenType]?: SupplyPosition } },
-  borrowPositions: { [key in Address]: { [key in PoolTokenType]?: BorrowPosition } },
-}
-
-export interface TvlData {
-  crossChainTVLUSD: number;
-  totalBalanceUSD: number;
-  totalBorrowsUSD: number;
-  totalSupplyUSD: number;
-}
-
-export interface AirdropData {
-  index: number;
-  amount: BigNumber;
-  proof: Array<string>;
-}
-
-export interface ClaimEvent {
-  amount: number;
-  transactionHash: string;
-}
-
-export interface XimxData {
-  totalSupply: string;
-  totalBalance: string;
-  exchangeRate: string;
-  dailyAPR: string;
-}
-
-export interface PendingRewardUI {
-  symbol: string; 
-  amount: number;
-}