impermax-sdk 1.0.0

package/impermax-router/LendingPool.ts

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

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

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

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

package/index.ts

@@ -0,0 +1,5 @@
+import Subgraph from './subgraph';
+import ImpermaxRouter from './impermax-router';
+
+exports.Subgraph = Subgraph;
+exports.ImpermaxRouter = ImpermaxRouter;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "impermax-sdk",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "ts-loader": "^8.0.14",
+    "typescript": "^4.0.3"
+  },
+  "dependencies": {
+    "apollo-cache-inmemory": "^1.6.6",
+    "apollo-client": "^2.6.10",
+    "apollo-link-http": "^1.5.17",
+    "ethers": "^5.0.26",
+    "graphql": "^15.4.0",
+    "graphql-tag": "^2.11.0"
+  }
+}