impermax-sdk 1.0.0

package/subgraph/PoolToken.ts

@@ -0,0 +1,381 @@
+import { BorrowableData, PoolTokenData, BorrowablePastData } from "../impermax-router/interfaces";
+import { toAPR } from "../utils";
+
+import LendingPool from "./LendingPool";
+import { Address, PoolTokenType } from '../config/types';
+import { ETH_NAME, ETH_SYMBOL } from '../config/eth';
+import { IMX } from '../config/contracts/imxes';
+import { WETH } from '../config/contracts/weths';
+
+export default class PoolToken {
+  lendingPool: LendingPool;
+  poolTokenType: PoolTokenType;
+
+  constructor(lendingPool: LendingPool, poolTokenType: PoolTokenType) {
+    this.lendingPool = lendingPool;
+    this.poolTokenType = poolTokenType;
+  }
+
+  // Subgraph calls
+  async getPoolTokenData() : Promise<PoolTokenData> {
+    const lendingPoolData = await this.lendingPool.getLendingPoolData();
+    return lendingPoolData[this.poolTokenType];
+  }
+  
+  // Helpers
+  private async getPoolTokenParam(param: string) : Promise<string> {
+    const poolTokenData = await this.getPoolTokenData() as any;
+    return poolTokenData[param];
+  }
+  private async getPoolTokenParamFloat(param: string) : Promise<number> {
+    return parseFloat(await this.getPoolTokenParam(param));
+  }
+  private async getUnderlyingParam(param: string) : Promise<string> {
+    const poolTokenData = await this.getPoolTokenData() as any;
+    return poolTokenData.underlying[param];
+  }
+
+  // Name
+  async getName() : Promise<string> {
+    if (this.poolTokenType == PoolTokenType.Collateral) {
+      const nameA = await this.lendingPool.poolTokens[PoolTokenType.BorrowableA].getName();
+      const nameB = await this.lendingPool.poolTokens[PoolTokenType.BorrowableB].getName();
+      return nameA + '-' + nameB + ' LP';
+    }
+    const underlying = await this.getUnderlyingAddress();
+    if (underlying.toLowerCase() === WETH[this.lendingPool.subgraph.network].toLowerCase()) return ETH_NAME[this.lendingPool.subgraph.network];
+    if (underlying.toLowerCase() === "0xa3fa99a148fa48d14ed51d610c367c61876997f1") return "MIMATIC";
+    if (underlying.toLowerCase() === "0x2e9a6df78e42a30712c10a9dc4b1c8656f8f2879") return "Maker";
+    return this.getUnderlyingParam("name");
+  }
+
+  // Symbol
+  async getSymbol() : Promise<string> {
+    if (this.poolTokenType == PoolTokenType.Collateral) {
+      const symbolA = await this.lendingPool.poolTokens[PoolTokenType.BorrowableA].getSymbol();
+      const symbolB = await this.lendingPool.poolTokens[PoolTokenType.BorrowableB].getSymbol();
+      return symbolA + '-' + symbolB;
+    }
+    const underlying = await this.getUnderlyingAddress();
+    if (underlying.toLowerCase() === WETH[this.lendingPool.subgraph.network].toLowerCase()) return ETH_SYMBOL[this.lendingPool.subgraph.network];
+    if (underlying.toLowerCase() === "0xa3fa99a148fa48d14ed51d610c367c61876997f1") return "MAI";
+    if (underlying.toLowerCase() === "0x2e9a6df78e42a30712c10a9dc4b1c8656f8f2879") return "MKR";
+    if (underlying.toLowerCase() === "0xc165d941481e68696f43ee6e99bfb2b23e0e3114") return "OXDv1";
+    if (underlying.toLowerCase() === "0xc5a9848b9d145965d821aaec8fa32aaee026492d") return "OXDv2";
+    if (underlying.toLowerCase() === "0x6ae7dfc73e0dde2aa99ac063dcf7e8a63265108c") return "JPYCv1";
+    if (underlying.toLowerCase() === "0x431d5dff03120afa4bdf332c61a6e1766ef37bdb") return "JPYCv2";
+    return this.getUnderlyingParam("symbol");
+  }
+
+  // Decimals
+  async getDecimals() : Promise<number> {
+    if (this.poolTokenType == PoolTokenType.Collateral) return 18;
+    return parseInt(await this.getUnderlyingParam("decimals"));
+  }
+
+  // ExchangeRate
+  async getExchangeRate() : Promise<number> {
+    return this.getPoolTokenParamFloat("exchangeRate");
+  }
+
+  // Underlying Address
+  async getUnderlyingAddress() : Promise<Address> {
+    if (this.poolTokenType == PoolTokenType.Collateral) return this.lendingPool.pairAddress;
+    return this.getUnderlyingParam("id");
+  }
+
+  // Total balance
+  async getTotalBalance() : Promise<number> {
+    return this.getPoolTokenParamFloat("totalBalance");
+  }
+  async getTotalBalanceUSD() : Promise<number> {
+    const totalBalance = await this.getTotalBalance();
+    const tokenPrice = await this.getTokenPriceFast();
+    return totalBalance * tokenPrice;
+  }
+
+  // Reserve Factor
+  async getReserveFactor() : Promise<number> {
+    return this.getPoolTokenParamFloat("reserveFactor");
+  }
+  
+  // Kink Borrow Rate
+  async getKinkBorrowRate() : Promise<number> {
+    return this.getPoolTokenParamFloat("kinkBorrowRate");
+  }
+  
+  // Kink Utilization Rate
+  async getKinkUtilizationRate() : Promise<number> {
+    return this.getPoolTokenParamFloat("kinkUtilizationRate");
+  }
+
+  // Borrow Index
+  async getBorrowIndex() : Promise<number> {
+    return this.getPoolTokenParamFloat("borrowIndex");
+  }
+  
+  // Accrue Timestamp
+  async getAccrualTimestamp() : Promise<number> {
+    return this.getPoolTokenParamFloat("accrualTimestamp");
+  }
+
+  // Total borrows
+  async getTotalBorrows() : Promise<number> {
+    return this.getPoolTokenParamFloat("totalBorrows");
+  }
+  async getCurrentTotalBorrows() : Promise<number> {
+    const storedAmount = await this.getTotalBorrows();
+    const accrualTimestamp = await this.getAccrualTimestamp();
+    const borrowRate = await this.getBorrowRate();
+    return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * borrowRate);
+  }
+  async getTotalBorrowsUSD() : Promise<number> {
+    const totalBorrows = await this.getCurrentTotalBorrows();
+    const tokenPrice = await this.getTokenPriceFast();
+    return totalBorrows * tokenPrice;
+  }
+
+  // Borrow rate
+  async getBorrowRate() : Promise<number> {
+    return this.getPoolTokenParamFloat("borrowRate");
+  }
+  async getBorrowAPR() : Promise<number> {
+    const borrowRate = await this.getBorrowRate();
+    return toAPR(borrowRate);
+  }
+  async getNextBorrowRate(borrowAmount: number) : Promise<number> {
+    const totalBorrows = await this.getTotalBorrows();
+    const supply = await this.getSupply();
+    const UR = (borrowAmount + totalBorrows) / supply;
+    const kinkBR = await this.getKinkBorrowRate();
+    const kinkUR = await this.getKinkUtilizationRate();
+    if (UR < kinkUR) return UR / kinkUR * kinkBR;
+    const kinkMultiplier = this.lendingPool.getKinkMultiplier();
+    return ((UR - kinkUR) / (1 - kinkUR) * (kinkMultiplier - 1) + 1) * kinkBR;
+  }
+  async getNextBorrowAPR(borrowAmount: number) : Promise<number> {
+    const borrowRate = await this.getNextBorrowRate(borrowAmount);
+    return toAPR(borrowRate);
+  }
+
+  // Supply
+  async getSupply() : Promise<number> {
+    const totalBalance = await this.getTotalBalance();
+    const totalBorrows = await this.getTotalBorrows();
+    return totalBalance + totalBorrows;
+  }
+  async getCurrentSupply() : Promise<number> {
+    const storedAmount = await this.getSupply();
+    const accrualTimestamp = await this.getAccrualTimestamp();
+    const supplyRate = await this.getSupplyRate();
+    return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * supplyRate);
+  }
+  async getSupplyUSD() : Promise<number> {
+    const supply = await this.getCurrentSupply();
+    const tokenPrice = await this.getTokenPriceFast();
+    return supply * tokenPrice;
+  }
+
+  // Utilization Rate
+  async getUtilizationRate() : Promise<number> {
+    const supply = await this.getSupply();
+    if (supply == 0) return 0;
+    const totalBalance = await this.getTotalBorrows();
+    return totalBalance / supply;
+  }
+
+  // Supply Rate
+  async getSupplyRate() : Promise<number> {
+    const borrowRate = await this.getBorrowRate();
+    const utilizationRate = await this.getUtilizationRate();
+    const reserveFactor = await this.getReserveFactor();
+    return borrowRate * utilizationRate * (1 - reserveFactor);
+  }
+  async getSupplyAPR() : Promise<number> {
+    const supplyRate = await this.getSupplyRate();
+    return toAPR(supplyRate);
+  }
+  async getNextSupplyRate(supplyAmount: number) : Promise<number> {
+    const totalBorrows = await this.getTotalBorrows();
+    const supply = await this.getSupply();
+    const UR = totalBorrows / (supply + supplyAmount);
+    const kinkBR = await this.getKinkBorrowRate();
+    const kinkUR = await this.getKinkUtilizationRate();
+    const reserveFactor = await this.getReserveFactor();
+    if (UR < kinkUR) return UR / kinkUR * kinkBR * UR * (1 - reserveFactor);
+    const kinkMultiplier = this.lendingPool.getKinkMultiplier();
+    return ((UR - kinkUR) / (1 - kinkUR) * (kinkMultiplier - 1) + 1) * kinkBR * UR * (1 - reserveFactor);
+  }
+  async getNextSupplyAPR(supplyAmount: number) : Promise<number> {
+    const supplyRate = await this.getNextSupplyRate(supplyAmount);
+    return toAPR(supplyRate);
+  }
+
+  // Reward Speed
+  async getFarmingRewardsRate() : Promise<Array<{
+    rewardToken: string,
+    rewardRate: number
+  }>> {
+    const poolTokenData = await this.getPoolTokenData() as BorrowableData;
+    const rewards = poolTokenData.rewards;
+    if (rewards && rewards.length > 0) return rewards;
+  
+    const FINISH_DELAY = 3600 * 24;
+    const farmingPoolData = poolTokenData.farmingPool;
+    if (farmingPoolData === null) return [];
+    const segmentLength = parseInt(farmingPoolData.segmentLength);
+    const epochAmount = parseFloat(farmingPoolData.epochAmount);
+    const epochBegin = parseInt(farmingPoolData.epochBegin);
+    const epochEnd = epochBegin + segmentLength;
+    const timestamp = (new Date()).getTime() / 1000;
+    if (timestamp - FINISH_DELAY > epochEnd) {
+      // How to manage better this case? Maybe check shares on distributor
+      return [];
+    }
+    return [{
+      rewardToken: IMX[this.lendingPool.subgraph.network],
+      rewardRate: epochAmount / segmentLength
+    }];
+  }
+
+  // Farming
+  async getFarmingRewards() : Promise<Array<{
+    APR: number,
+    symbol: string,
+  }>> {
+    return this.getNextFarmingRewards(0);
+  }
+  async getNextFarmingRewards(borrowAmount: number) : Promise<Array<{
+    APR: number,
+    symbol: string,
+  }>> {
+    const farmingRewards = await this.getFarmingRewardsRate();
+    const currentBorrowedUSD = await this.getTotalBorrowsUSD();
+    const tokenPrice = await this.getTokenPriceFast();
+    const additionalBorrowsUSD = borrowAmount * tokenPrice;
+    const totalBorrowedUSD = currentBorrowedUSD + additionalBorrowsUSD;
+    if (totalBorrowedUSD === 0) return [];
+  
+    const rewards = [];
+    for(const reward of farmingRewards) {
+      const rewardPrice = await this.lendingPool.subgraph.priceHelper.getDebankTokenPrice(reward.rewardToken);
+      rewards.push({
+        APR: toAPR((rewardPrice * reward.rewardRate) / totalBorrowedUSD),
+        symbol: 
+          reward.rewardToken == "0x98878b06940ae243284ca214f92bb71a2b032b8a" ? "WMOVR" : 
+          reward.rewardToken == "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270" ? "WMATIC" : 
+          "IMX",
+      });
+    }
+    return rewards;
+  }
+  async getFarmingAPR() : Promise<number> {
+    return this.getNextFarmingAPR(0);
+  }
+  async getNextFarmingAPR(borrowAmount: number) : Promise<number> {
+    const rewards = await this.getNextFarmingRewards(borrowAmount);
+    let APR = 0;
+    for (const reward of rewards) {
+      APR += reward.APR
+    }
+    return APR;
+  }
+
+  // Past Data
+  async getPoolTokenDataPast24h() : Promise<BorrowablePastData> {
+    const lendingPoolDataPast = await this.lendingPool.getLendingPoolDataPast24h();
+    if (!lendingPoolDataPast) return undefined;
+    return lendingPoolDataPast[this.poolTokenType];
+  }
+  async getPoolTokenDataPast7d() : Promise<BorrowablePastData> {
+    const lendingPoolDataPast = await this.lendingPool.getLendingPoolDataPast7d();
+    if (!lendingPoolDataPast) return undefined;
+    return lendingPoolDataPast[this.poolTokenType];
+  }
+    
+  // Average Borrow APR
+  private async getAverageBorrowAPR(poolTokenDataPast: BorrowablePastData, fallback: Promise<number>) : Promise<number> {
+    if (poolTokenDataPast) {
+      const accrualTimestampPast = parseFloat(poolTokenDataPast.accrualTimestamp);
+      const borrowIndexPast = parseFloat(poolTokenDataPast.borrowIndex);
+      const accrualTimestampNow = await this.getAccrualTimestamp();
+      const borrowIndexNow = await this.getBorrowIndex();
+      if (accrualTimestampNow > accrualTimestampPast) {
+        const borrowRate = (borrowIndexNow / borrowIndexPast - 1) / (accrualTimestampNow - accrualTimestampPast);
+        return borrowRate * 3600 * 24 * 365;
+      }
+    }
+    return fallback;
+  }
+  async getAverage24hBorrowAPR() : Promise<number> {
+    const poolTokenDataPast = await this.getPoolTokenDataPast24h();
+    return this.getAverageBorrowAPR(poolTokenDataPast, this.getBorrowAPR());
+  }
+  async getAverage7dBorrowAPR() : Promise<number> {
+    const poolTokenDataPast = await this.getPoolTokenDataPast7d();
+    return this.getAverageBorrowAPR(poolTokenDataPast, this.getAverage24hBorrowAPR());
+  }
+
+  // Average Supply APR
+  private async getAverageSupplyAPR(poolTokenDataPast: BorrowablePastData, fallback: Promise<number>) : Promise<number> {
+    if (poolTokenDataPast) {
+      const accrualTimestampPast = parseFloat(poolTokenDataPast.accrualTimestamp);
+      const exchangeRatePast = parseFloat(poolTokenDataPast.exchangeRate);
+      const accrualTimestampNow = await this.getAccrualTimestamp();
+      const exchangeRateNow = await this.getExchangeRate();
+      if (accrualTimestampNow > accrualTimestampPast) {
+        const supplyRate = (exchangeRateNow / exchangeRatePast - 1) / (accrualTimestampNow - accrualTimestampPast);
+        return supplyRate * 3600 * 24 * 365;
+      }
+    }
+    return fallback;
+  }
+  async getAverage24hSupplyAPR() : Promise<number> {
+    const poolTokenDataPast = await this.getPoolTokenDataPast24h();
+    return this.getAverageSupplyAPR(poolTokenDataPast, this.getSupplyAPR());
+  }
+  async getAverage7dSupplyAPR() : Promise<number> {
+    const poolTokenDataPast = await this.getPoolTokenDataPast7d();
+    return this.getAverageSupplyAPR(poolTokenDataPast, this.getAverage24hSupplyAPR());
+  }
+  
+  // Calculate collateral price -> returns the price of the collateral, not necessarily of the underlying LP
+  calculateCollateralPrice(reserve0: number, reserve1: number, totalSupply: number, price0: number, price1: number) : number {
+    if (totalSupply === 0) {
+      console.error("Warning: totalSupply is 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;
+  }
+
+  // Token price getters
+  async getTokenPriceFast(fallback: boolean = true) : Promise<number> {
+    let tokenPrice = 0;
+    if (this.poolTokenType != PoolTokenType.Collateral) {
+      //const poolTokenData = await this.getPoolTokenData() as BorrowableData;
+      //tokenPrice = parseFloat(poolTokenData.underlying.derivedUSD);
+      let tokenAddress = await this.getUnderlyingAddress();
+      let tokenPrices = await this.lendingPool.subgraph.priceHelper.getSubgraphTokenPrice();
+      tokenPrice = tokenPrices[tokenAddress];
+    } else {
+      tokenPrice = await this.lendingPool.getCollateralPrice(false)
+    }
+    if (tokenPrice > 0) return tokenPrice;
+    if (fallback) {
+      return this.getTokenPriceAccurate();
+    }
+    return 0;
+  }
+  async getTokenPriceAccurate() : Promise<number> {
+    if (this.poolTokenType === PoolTokenType.Collateral) {
+      return this.lendingPool.getCollateralPrice(false)
+    }
+    let tokenAddress = await this.getUnderlyingAddress();
+    return this.lendingPool.subgraph.priceHelper.getDebankTokenPrice(tokenAddress);
+  }
+
+}

package/subgraph/PriceHelper.ts

@@ -0,0 +1,150 @@
+import Subgraph from ".";
+import { DEBANK_IDS } from '../config/debank-ids';
+import { Address, Factory } from '../config/types';
+import { IMX } from '../config/contracts/imxes';
+
+// coingecko has priority over debank for initialized tokens
+const coingecko_ids : {[key in Address]: string} = {
+  // Arbitrum
+  "0xb348b87b23d5977e2948e6f36ca07e1ec94d7328": "swapfish",
+  "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f": "wrapped-bitcoin",
+}
+
+export default class PriceHelper {
+  subgraph: Subgraph;
+  subgraphTokenPrice: Promise<{
+    [key in Address]?: number
+  }>;
+  debankTokenPrice: {
+    [key in Address]?: Promise<number>
+  };
+
+  constructor(subgraph: Subgraph) {
+    this.subgraph = subgraph;
+    this.debankTokenPrice = {};
+  }
+
+  cleanCache() {
+    this.subgraphTokenPrice = null;
+    this.debankTokenPrice = {};
+  }
+  
+  // First source of token price: Subgraph (less accurate, faster)
+  
+  private async initializeSubgraphTokenPrice() : Promise<{[key in Address]: number}> {
+    const lendingPoolsData = await this.subgraph.getLendingPoolsData();
+    const subgraphTokenPrice: {[key in Address]: number} = {};
+    for (const factory of Object.keys(lendingPoolsData) as Factory[]) {
+      for (const id of Object.keys(lendingPoolsData[factory]) as Address[]) {
+        const lendingPool = lendingPoolsData[factory][id];
+        subgraphTokenPrice[lendingPool.borrowable0.underlying.id] = parseFloat(lendingPool.borrowable0.underlying.derivedUSD);
+        subgraphTokenPrice[lendingPool.borrowable1.underlying.id] = parseFloat(lendingPool.borrowable1.underlying.derivedUSD);
+        for (const reward of lendingPool.pair.rewards) {
+          subgraphTokenPrice[reward.rewardsToken.id] = parseFloat(reward.rewardsToken.derivedUSD);
+        }
+      }
+    }
+    //fix for IMX
+    subgraphTokenPrice["0x9c67ee39e3c4954396b9142010653f17257dd39c"] = 0;
+    subgraphTokenPrice["0x7b35ce522cb72e4077baeb96cb923a5529764a00"] = 0;
+    subgraphTokenPrice["0xea6887e4a9cda1b77e70129e5fba830cdb5cddef"] = 0;
+    subgraphTokenPrice["0x60bb3d364b765c497c8ce50ae0ae3f0882c5bd05"] = 0;
+    subgraphTokenPrice["0x900f1ec5819fa087d368877cd03b265bf1802667"] = 0;
+    subgraphTokenPrice["0xea38f1ccf77bf43f352636241b05dd8f6f5f52b2"] = 0;
+    return subgraphTokenPrice;
+  }
+  async getSubgraphTokenPrice() : Promise<{[key in Address]: number}> {
+    if (!this.subgraphTokenPrice) this.subgraphTokenPrice = this.initializeSubgraphTokenPrice();
+    return this.subgraphTokenPrice;
+  }
+  
+  // Second source of token price: Debank (more accurate, slower)
+  
+  private async getCoingeckoTokenPrice(tokenAddress: Address) : Promise<number> {
+    try {
+      const tokenId = coingecko_ids[tokenAddress];
+      const response = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=" + tokenId + "&vs_currencies=usd");
+      if (response.status != 200) return 0;
+      const data = await response.json();
+      if (!data) return 0;
+      return data[tokenId].usd ? data[tokenId].usd : 0;
+    }
+    catch {
+      return 0;
+    }
+  }
+  private async initializeDebankTokenPrice(tokenAddress: Address) : Promise<number> {
+    if (Object.keys(coingecko_ids).includes(tokenAddress.toLowerCase())) {
+      const result = this.getCoingeckoTokenPrice(tokenAddress.toLowerCase());
+      if (result) return result;
+    }
+    try {
+      const response = await fetch("https://openapi.debank.com/v1/token?chain_id=" + DEBANK_IDS[this.subgraph.network] + "&id=" + tokenAddress);
+      /*const response = await fetch(
+        "https://pro-openapi.debank.com/v1/token?chain_id=" + debank_chain_ids[this.subgraph.network] + "&id=" + tokenAddress,
+        {headers: {"AccessKey": "0ac0fba6aeb0905b4c9a1c5cfd9d48d74fbc60e0"}}
+      );*/
+      if (response.status != 200) return 0;
+      const data = await response.json();
+      if (!data) return 0;
+      return data.price ? data.price : 0;
+    }
+    catch {
+      return 0;
+    }
+  }
+  async getDebankTokenPrice(tokenAddress: Address) : Promise<number> {
+    if (tokenAddress.toLowerCase() === '0xb348b87b23d5977e2948e6f36ca07e1ec94d7328') { // fix for FISH
+      //return 0.07;
+    }
+    if (tokenAddress.toLowerCase() === '0xf28164a485b0b2c90639e47b0f377b4a438a16b1') { // fix for dQuick
+      return (await this.getDebankTokenPrice('0x831753dd7087cac61ab5644b308642cc1c33dc13')) * 1.68;
+    }
+    if (tokenAddress.toLowerCase() === '0x63468133ed352e602beb61dd254d6060ad2fe419') { // fix for sTHO
+      return (await this.getDebankTokenPrice('0xae4aa155d2987b454c29450ef4f862cf00907b61')) * 1.1;
+    }
+    if (tokenAddress.toLowerCase() === '0xfcef8a994209d6916eb2c86cdd2afd60aa6f54b1') { // fix for fBEETS
+      return (await this.getDebankTokenPrice('0xf24bcf4d1e507740041c9cfd2dddb29585adce1e')) * 0.93;
+    }
+    if (tokenAddress.toLowerCase() === '0x5979d7b546e38e414f7e9822514be443a4800529') { // TEMPORARY fix for WSTETH
+      return (await this.getDebankTokenPrice('0x82af49447d8a07e3bd95bd0d56f35241523fbab1')) / 0.92;
+    }
+    if (tokenAddress.toLowerCase() === '0x3f56e0c36d275367b8c502090edf38289b3dea0d') { // TEMPORARY fix for MAI
+      return 1;
+    }
+    if ([
+      "0x9c67ee39e3c4954396b9142010653f17257dd39c",
+      "0x7b35ce522cb72e4077baeb96cb923a5529764a00",
+      "0xea6887e4a9cda1b77e70129e5fba830cdb5cddef",
+      "0x60bb3d364b765c497c8ce50ae0ae3f0882c5bd05",
+      "0x900f1ec5819fa087d368877cd03b265bf1802667",
+      "0xea38f1ccf77bf43f352636241b05dd8f6f5f52b2",
+    ].includes(tokenAddress.toLowerCase())) { // fix for IMX
+      return 0;
+    }
+    if (tokenAddress.toLowerCase() === '0xda0053f0befcbcac208a3f867bb243716734d809') { // TEMPORARY fix for oxSOLID
+      return (await this.getDebankTokenPrice('0x888ef71766ca594ded1f0fa3ae64ed2941740a20')) * 0.88;
+    }
+    if (tokenAddress.toLowerCase() === '0x431d5dff03120afa4bdf332c61a6e1766ef37bdb') { // TEMPORARY fix for JPYCv2
+      return (await this.getDebankTokenPrice('0x6ae7dfc73e0dde2aa99ac063dcf7e8a63265108c'));
+    }
+    if (!this.debankTokenPrice[tokenAddress]) this.debankTokenPrice[tokenAddress] = this.initializeDebankTokenPrice(tokenAddress);
+    const tokenPrice = await this.debankTokenPrice[tokenAddress];
+    if (tokenPrice === 0) {
+      // try fallback on subgraph
+      const subgraphTokenPrice = await this.getSubgraphTokenPrice();
+      return subgraphTokenPrice[tokenAddress] ? subgraphTokenPrice[tokenAddress] : 0;
+    }
+    return tokenPrice;
+  }
+  
+  async getImxPrice() : Promise<number> {
+    const imx = IMX[this.subgraph.network];
+    if (!imx) return 0;
+    const imxPrice = await this.getDebankTokenPrice(imx);
+    if (imxPrice != 0) return imxPrice;
+    const subgraphTokenPrice = await this.getSubgraphTokenPrice();
+    if (subgraphTokenPrice[imx]) return subgraphTokenPrice[imx]
+    return 0;
+  }
+}

package/subgraph/SolidexHelper.ts

@@ -0,0 +1,54 @@
+import Subgraph from ".";
+import { Address } from "../config/types";
+
+export type SolidexLPDetails = {
+  [key in Address]: Array<{
+    APR: number,
+    symbol: string,
+  }>
+}
+
+export default class SolidexHelper {
+  subgraph: Subgraph;
+  solidexLPDetails: Promise<SolidexLPDetails>;
+
+  constructor(subgraph: Subgraph) {
+    this.subgraph = subgraph;
+  }
+
+  cleanCache() {
+    this.solidexLPDetails = null;
+  }
+  
+  private async initializeSolidexLPDetails() : Promise<SolidexLPDetails> {
+    try {
+      const response = await fetch("https://api.solidexfinance.com/api/getLPDetails?v=fantom");
+      if (response.status != 200) return {};
+      const data = await response.json();
+      if (!data || !data.success) return {};
+      const solidexLPDetails: SolidexLPDetails = {};
+      for (const pool of data.data.poolDetailsAll) {
+        if (!pool.solidexTVL) continue;
+        solidexLPDetails[pool.poolAddress.toLowerCase()] = [
+          {
+            APR: pool.solidexTVL.realsolidAPR / 100,
+            symbol: "SOLID",
+          },
+          {
+            APR: pool.solidexTVL.realsexAPR / 100,
+            symbol: "SEX",
+          },
+        ]
+      }
+      return solidexLPDetails;
+    }
+    catch (e) {
+      return {};
+    }
+  }
+  
+  async getSolidexLPDetails() : Promise<SolidexLPDetails> {
+    if (!this.solidexLPDetails) this.solidexLPDetails = this.initializeSolidexLPDetails();
+    return this.solidexLPDetails;
+  }
+}