impermax-sdk 1.0.0

package/subgraph/Account.ts

@@ -0,0 +1,93 @@
+import { UserData } from "../impermax-router/interfaces";
+
+import Subgraph from ".";
+import AccountLendingPool from "./AccountLendingPool";
+import { Address, Factory, FactoryIndex, LendingPoolIndex, PoolTokenType } from '../config/types';
+
+export default class Account {
+  subgraph: Subgraph;
+  account: Address;
+  accountLLPs: LendingPoolIndex<Promise<AccountLendingPool>>;
+
+  constructor(subgraph: Subgraph, account: Address) {
+    this.subgraph = subgraph;
+    this.account = account;
+    this.accountLLPs = {}
+  }
+
+  private async initializeAccountLendingPool(factory: Factory, pair: Address) : Promise<AccountLendingPool> {
+    const lendingPool = await this.subgraph.getLendingPool(factory, 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];
+  }
+
+  async getUserData() : Promise<FactoryIndex<UserData>> {
+    return this.subgraph.getUserData(this.account);
+  }
+
+  async getBorrowPositions() : Promise<FactoryIndex<Address[]>> {
+    const result: FactoryIndex<Address[]> = {};
+    const userData = await this.getUserData();
+    for (const factory of Object.keys(userData) as Factory[]) {
+      result[factory] = Object.keys(userData[factory].collateralPositions);
+    }
+    return result;
+  }
+  
+  async getSupplyPositions() : Promise<FactoryIndex<Address[]>> {
+    const result: FactoryIndex<Address[]> = {};
+    const userData = await this.getUserData();
+    for (const factory of Object.keys(userData) as Factory[]) {
+      result[factory] = Object.keys(userData[factory].supplyPositions);
+    }
+    return result;
+  }
+
+  async getAccountTotalValueLocked() : Promise<number> {
+    const borrowPositions = await this.getBorrowPositions();
+    const supplyPositions = await this.getSupplyPositions();
+    let tvl = 0;
+    for (const factory of Object.keys(borrowPositions) as Factory[]) {
+      for (const uniswapV2PairAddress of borrowPositions[factory]) {
+        const accountLendingPool = await this.getAccountLendingPool(factory, uniswapV2PairAddress);
+        tvl += await accountLendingPool.getBorrowerEquityValue();
+      }
+      for (const uniswapV2PairAddress of supplyPositions[factory]) {
+        const accountLendingPool = await this.getAccountLendingPool(factory, uniswapV2PairAddress);
+        tvl += await accountLendingPool.accountPoolTokens[PoolTokenType.BorrowableA].getSuppliedValue();
+        tvl += await accountLendingPool.accountPoolTokens[PoolTokenType.BorrowableB].getSuppliedValue();
+      }
+    }
+    return tvl;
+  }
+  
+  async getAccountTotalValueSupplied() : Promise<number> {
+    const supplyPositions = await this.getSupplyPositions();
+    let tvl = 0;
+    for (const factory of Object.keys(supplyPositions) as Factory[]) {
+      for (const uniswapV2PairAddress of supplyPositions[factory]) {
+        const accountLendingPool = await this.getAccountLendingPool(factory, uniswapV2PairAddress);
+        tvl += await accountLendingPool.accountPoolTokens[PoolTokenType.BorrowableA].getSuppliedValue();
+        tvl += await accountLendingPool.accountPoolTokens[PoolTokenType.BorrowableB].getSuppliedValue();
+      }
+    }
+    return tvl;
+  }
+  
+  async getAccountTotalValueBorrowed() : Promise<number> {
+    const borrowPositions = await this.getBorrowPositions();
+    let tvl = 0;
+    for (const factory of Object.keys(borrowPositions) as Factory[]) {
+      for (const uniswapV2PairAddress of borrowPositions[factory]) {
+        const accountLendingPool = await this.getAccountLendingPool(factory, uniswapV2PairAddress);
+        tvl += await accountLendingPool.accountPoolTokens[PoolTokenType.BorrowableA].getBorrowedValue();
+        tvl += await accountLendingPool.accountPoolTokens[PoolTokenType.BorrowableB].getBorrowedValue();
+      }
+    }
+    return tvl;
+  }
+}

package/subgraph/AccountLendingPool.ts

@@ -0,0 +1,60 @@
+import { CollateralPosition, UserData } from "../impermax-router/interfaces";
+import Account from "./Account";
+import AccountPoolToken from "./AccountPoolToken";
+
+import LendingPool from "./LendingPool";
+import { PoolTokenType } from '../config/types';
+
+export default class AccountLendingPool {
+  account: Account;
+  lendingPool: LendingPool;
+  accountPoolTokens: {
+    [key in PoolTokenType]?: AccountPoolToken
+  }
+
+  constructor(account: Account, lendingPool: LendingPool) {
+    this.account = account;
+    this.lendingPool = lendingPool;
+    this.accountPoolTokens = {};
+    this.accountPoolTokens[PoolTokenType.Collateral] = new AccountPoolToken(this, PoolTokenType.Collateral);
+    this.accountPoolTokens[PoolTokenType.BorrowableA] = new AccountPoolToken(this, PoolTokenType.BorrowableA);
+    this.accountPoolTokens[PoolTokenType.BorrowableB] = new AccountPoolToken(this, PoolTokenType.BorrowableB);
+  }
+
+  getAccountPoolToken(poolTokenType: PoolTokenType) : AccountPoolToken {
+    return this.accountPoolTokens[poolTokenType];
+  }
+
+  async getUserData() : Promise<UserData> {
+    const userData = await this.account.getUserData();
+    if(!userData) return null;
+    return userData[this.lendingPool.factory];
+  }
+
+  async getCollateralPosition() : Promise<CollateralPosition> {
+    const userData = await this.getUserData();
+    if(!userData) return null;
+    return userData.collateralPositions[this.lendingPool.pairAddress];
+  }
+
+  async getCollateralAmount() : Promise<number> {
+    const collateralPosition = await this.getCollateralPosition();
+    if(!collateralPosition) return 0;
+    const exchangeRate = await this.lendingPool.poolTokens[PoolTokenType.Collateral].getExchangeRate();
+    const collateralBalance = parseFloat(collateralPosition.balance);
+    return collateralBalance * exchangeRate;    
+  }
+
+  async getCollateralValue() : Promise<number> {
+    const tokenPrice = await this.lendingPool.poolTokens[PoolTokenType.Collateral].getTokenPriceAccurate();
+    const collateralAmount = await this.getCollateralAmount();
+    return collateralAmount * tokenPrice;
+  }
+
+  async getBorrowerEquityValue() : Promise<number> {
+    const collateralValue = await this.getCollateralValue();
+    const borrowedValueA = await this.accountPoolTokens[PoolTokenType.BorrowableA].getBorrowedValue();
+    const borrowedValueB = await this.accountPoolTokens[PoolTokenType.BorrowableB].getBorrowedValue();
+    return collateralValue - borrowedValueA - borrowedValueB;
+  }
+}

package/subgraph/AccountPoolToken.ts

@@ -0,0 +1,60 @@
+import { BorrowPosition, SupplyPosition } from "../impermax-router/interfaces";
+import AccountLendingPool from "./AccountLendingPool";
+
+import PoolToken from "./PoolToken";
+import { PoolTokenType } from '../config/types';
+
+export default class AccountPoolToken {
+  accountLendingPool: AccountLendingPool;
+  poolToken: PoolToken;
+
+  constructor(accountLendingPool: AccountLendingPool, poolTokenType: PoolTokenType) {
+    this.accountLendingPool = accountLendingPool;
+    this.poolToken = accountLendingPool.lendingPool.poolTokens[poolTokenType];
+  }
+
+  private async getBorrowPosition() : Promise<BorrowPosition> {
+    const userData = await this.accountLendingPool.getUserData();
+    if(!userData) return null;
+    const borrowPositions = userData.borrowPositions[this.poolToken.lendingPool.pairAddress];
+    if(!borrowPositions) return null;
+    return borrowPositions[this.poolToken.poolTokenType];
+  }
+
+  private async getSupplyPosition() : Promise<SupplyPosition> {
+    const userData = await this.accountLendingPool.getUserData();
+    if(!userData) return null;
+    const supplyPositions = userData.supplyPositions[this.poolToken.lendingPool.pairAddress];
+    if(!supplyPositions) return null;
+    return supplyPositions[this.poolToken.poolTokenType];
+  }
+
+  async getBorrowedAmount() : Promise<number> {
+    const borrowPosition = await this.getBorrowPosition();
+    const borrowIndex = await this.poolToken.getBorrowIndex();
+    if(!borrowPosition) return 0;
+    const borrowBalance = parseFloat(borrowPosition.borrowBalance);
+    const userBorrowIndex = parseFloat(borrowPosition.borrowIndex);
+    return borrowBalance * borrowIndex / userBorrowIndex;
+  }
+
+  async getBorrowedValue() : Promise<number> {
+    const tokenPrice = await this.poolToken.getTokenPriceAccurate();
+    const borrowedAmount = await this.getBorrowedAmount();
+    return borrowedAmount * tokenPrice;
+  }
+
+  async getSuppliedAmount() : Promise<number> {
+    const supplyPosition = await this.getSupplyPosition();
+    if(!supplyPosition) return 0;
+    const exchangeRate = await this.poolToken.getExchangeRate();
+    const supplyBalance = parseFloat(supplyPosition.balance);
+    return supplyBalance * exchangeRate;
+  }
+  
+  async getSuppliedValue() : Promise<number> {
+    const tokenPrice = await this.poolToken.getTokenPriceAccurate();
+    const suppliedAmount = await this.getSuppliedAmount();
+    return suppliedAmount * tokenPrice;
+  }
+}

package/subgraph/LendingPool.ts

@@ -0,0 +1,179 @@
+import { LendingPoolData, LendingPoolPastData } from "../impermax-router/interfaces";
+
+import Subgraph from ".";
+import PoolToken from "./PoolToken";
+import { toAPR } from "../utils";
+import { Address, Amms, Factory, PoolTokenType } from '../config/types';
+import { getAmmByFactory } from '../config/amms';
+import { OLD_KINK_MULTIPLIER_FACTORIES } from '../config/factories';
+import { Farms, getFarmByStakedLPFactory } from '../config/farms';
+
+export default class LendingPool {
+  subgraph: Subgraph;
+  factory: Factory;
+  pairAddress: Address;
+  poolTokens: {
+    [key in PoolTokenType]?: PoolToken
+  };
+
+  constructor(subgraph: Subgraph, factory: Factory, pairAddress: Address) {
+    this.subgraph = subgraph;
+    this.factory = factory;
+    this.pairAddress = pairAddress;
+    this.poolTokens = {};
+    this.poolTokens[PoolTokenType.Collateral] = new PoolToken(this, PoolTokenType.Collateral);
+    this.poolTokens[PoolTokenType.BorrowableA] = new PoolToken(this, PoolTokenType.BorrowableA);
+    this.poolTokens[PoolTokenType.BorrowableB] = new PoolToken(this, PoolTokenType.BorrowableB);
+  }
+
+  getPoolToken(poolTokenType: PoolTokenType) : PoolToken {
+    return this.poolTokens[poolTokenType];
+  }
+
+  // Subgraph calls
+  async getLendingPoolData() : Promise<LendingPoolData> {
+    return this.subgraph.getLendingPoolData(this.factory, this.pairAddress);
+  }
+
+  // Safety Margin
+  async getSafetyMargin() : Promise<number> {
+    const lendingPoolData = await this.getLendingPoolData();
+    return parseFloat(lendingPoolData[PoolTokenType.Collateral].safetyMargin);
+  }
+  
+  // Liquidation Penalty
+  async getLiquidationIncentive() : Promise<number> {
+    const lendingPoolData = await this.getLendingPoolData();
+    return parseFloat(lendingPoolData[PoolTokenType.Collateral].liquidationIncentive);
+  }
+  async getLiquidationFee() : Promise<number> {
+    const lendingPoolData = await this.getLendingPoolData();
+    const liquidationFee = lendingPoolData[PoolTokenType.Collateral].liquidationFee;
+    return liquidationFee ? parseFloat(liquidationFee) : 0;
+  }
+  async getLiquidationPenalty() : Promise<number> {
+    return await this.getLiquidationIncentive() + await this.getLiquidationFee();
+  }
+
+  // Uniswap APR
+  async getUniswapAPR() : Promise<number> {
+    const lendingPoolData = await this.getLendingPoolData();
+    return lendingPoolData.pair.uniswapAPR;
+  }
+
+  // Staking
+  async isStakedLPToken() : Promise<boolean> {
+    const lendingPoolData = await this.getLendingPoolData();
+    return lendingPoolData.pair.isStakedLPToken;
+  }
+  async getStakedLPExchangeRate() : Promise<number> {
+    const lendingPoolData = await this.getLendingPoolData();
+    return parseFloat(lendingPoolData.pair.exchangeRate);
+  }
+  async getStakingRewards(): Promise<Array<{
+    APR: number,
+    symbol: string,
+  }>> {
+    const farm = await this.getFarm();
+    const lendingPoolData = await this.getLendingPoolData();
+    
+    if (farm === Farms.solidex || farm === Farms.solidexB || farm === Farms.solidexUSDC || farm === Farms.solidexUSDCB) {
+      const solidexLPDetails = await this.subgraph.solidexHelper.getSolidexLPDetails();
+      const result = solidexLPDetails[lendingPoolData.pair.uniswapV2PairAddress];
+      if (result) return result;
+    }
+  
+    const FINISH_DELAY = 3600 * 24 * 1;
+    const rewards = [];
+    const stakedTotalSupply = parseFloat(lendingPoolData.pair.stakedTotalSupply);
+    const underlyingLPPrice = await this.getUnderlyingLPPrice(true);
+    for(const reward of lendingPoolData.pair.rewards) {
+      const multiplier = farm === Farms.traderJoeV2 ? 0.5 : 1;
+      const periodFinish = parseInt(reward.periodFinish);
+      if ((new Date).getTime() / 1000 - FINISH_DELAY > periodFinish && periodFinish !== 0) continue;
+      let rewardRate = parseFloat(reward.rewardRate);
+      if (farm == Farms.traderJoeV4) rewardRate = rewardRate * 0.45;
+      const rewardPrice = await this.subgraph.priceHelper.getDebankTokenPrice(reward.rewardsToken.id);
+      rewards.push({
+        APR: toAPR((rewardPrice * rewardRate) / (stakedTotalSupply * underlyingLPPrice) * multiplier),
+        symbol: reward.rewardsToken.symbol,
+      });
+    }
+    return rewards;
+  }
+  async getStakingAPR() : Promise<number> {
+    const rewards = await this.getStakingRewards();
+    let APR = 0;
+    for (const reward of rewards) {
+      APR += reward.APR
+    }
+    return APR;
+  }
+
+  //Shown Leverage
+  async getShownLeverage() : Promise<number> {
+    const safetyMargin = await this.getSafetyMargin();
+    if (safetyMargin < 1.25) return 20;
+    if (safetyMargin < 1.51) return 10;
+    if (safetyMargin < 2.01) return 5;
+    return 3;
+  }
+
+  // Past Data
+  async getLendingPoolDataPast24h() : Promise<LendingPoolPastData> {
+    return (await this.getLendingPoolData()).past24h;
+  }
+  async getLendingPoolDataPast7d() : Promise<LendingPoolPastData> {
+    return (await this.getLendingPoolData()).past7d;
+  }
+
+  // Amms and farms
+  async getAmm() : Promise<Amms> {
+    const lendingPoolData = await this.getLendingPoolData();
+    return getAmmByFactory(this.subgraph.network, lendingPoolData.pair.uniswapV2Factory);
+  }
+  async getFarm() : Promise<Farms> {
+    const lendingPoolData = await this.getLendingPoolData();
+    return getFarmByStakedLPFactory(this.subgraph.network, lendingPoolData.pair.factory);
+  }
+
+  // getCollateralPrice -> returns the price of the collateral, not necessarily of the underlying LP
+  private calculateCollateralPrice(reserve0: number, reserve1: number, totalSupply: number, price0: number, price1: number) : number {
+    if (totalSupply === 0) return 0;
+    const reserve0USD = reserve0 * price0;
+    const reserve1USD = reserve1 * price1;
+    // adjust reserves taking the latest price passed as parameters
+    const adjustedReserveUSD = Math.sqrt(reserve0USD * reserve1USD) * 2;
+    return adjustedReserveUSD / totalSupply;
+  }
+  async getCollateralPrice(fast: boolean = true) : Promise<number> {
+    const lendingPoolData = await this.getLendingPoolData();
+    return this.calculateCollateralPrice(
+      parseFloat(lendingPoolData.pair.reserve0),
+      parseFloat(lendingPoolData.pair.reserve1),
+      parseFloat(lendingPoolData.pair.totalSupply),
+      fast ?
+        await this.poolTokens[PoolTokenType.BorrowableA].getTokenPriceFast() :
+        await this.poolTokens[PoolTokenType.BorrowableA].getTokenPriceAccurate(),
+      fast ?
+        await this.poolTokens[PoolTokenType.BorrowableB].getTokenPriceFast() :
+        await this.poolTokens[PoolTokenType.BorrowableB].getTokenPriceAccurate(),
+    );
+  }
+  async getUnderlyingLPPrice(fast: boolean = true) {
+    return await this.getCollateralPrice(fast) / await this.getStakedLPExchangeRate();
+  }
+
+  // Kink Multiplier
+  getKinkMultiplier() {
+    if (OLD_KINK_MULTIPLIER_FACTORIES.includes(this.factory)) return 5;
+    return 2;
+  }
+
+  // Stats
+  async getTotalBorrowsUSD() {
+    const totalBorrowsUSDA = await this.poolTokens[PoolTokenType.BorrowableA].getTotalBorrowsUSD();
+    const totalBorrowsUSDB = await this.poolTokens[PoolTokenType.BorrowableB].getTotalBorrowsUSD();
+    return totalBorrowsUSDA + totalBorrowsUSDB;
+  }
+}