impermax-sdk 1.0.0

package/subgraph/index.ts

@@ -0,0 +1,166 @@
+import { LendingPoolData, TvlData, UserData, XimxData } from "../impermax-router/interfaces";
+
+import * as initializer from "./initializer";
+import LendingPool from "./LendingPool";
+import PriceHelper from "./PriceHelper";
+import SolidexHelper from "./SolidexHelper";
+import Account from "./Account";
+import { Address, Factory, FactoryIndex, LendingPoolIndex, Networks } from '../config/types';
+
+export interface SubgraphCfg {
+  network: Networks;
+  chainId: number;
+  whitelistedPairs?: FactoryIndex<Address[]>;
+}
+
+export default class Subgraph {
+  network: Networks;
+  chainId: number;
+  whitelistedPairs?: FactoryIndex<Address[]>;
+  lendingPools: LendingPoolIndex<LendingPool>;
+  accounts: {
+    [key in Address]?: Account
+  };
+  priceHelper: PriceHelper;
+  solidexHelper: SolidexHelper;
+  lendingPoolsData: Promise<LendingPoolIndex<LendingPoolData>>;
+  usersData: {
+    [key in Address]?: Promise<FactoryIndex<UserData>>
+  };
+  tvlData: Promise<TvlData>;
+  ximxData: Promise<XimxData>;
+
+  constructor(cfg: SubgraphCfg) {
+    this.network = cfg.network as Networks;
+    this.chainId = cfg.chainId;
+    this.whitelistedPairs = cfg.whitelistedPairs;
+    this.priceHelper = new PriceHelper(this);
+    this.solidexHelper = new SolidexHelper(this);
+    this.accounts = {};
+    this.usersData = {};
+  }
+
+  cleanCache() {
+    this.lendingPoolsData = null;
+    this.usersData = {};
+    this.tvlData = null;
+    this.ximxData = null;
+    this.priceHelper.cleanCache();
+    this.solidexHelper.cleanCache();
+  }
+
+  async getLendingPool(factory: Factory, pairAddress: Address) : Promise<LendingPool> {
+    await this.getLendingPoolsData(); // make sure that lending pools are initialized
+    return this.lendingPools[factory][pairAddress];
+  }
+
+  getAccount(account: Address) : Account {
+    if (!this.accounts[account]) this.accounts[account] = new Account(this, account);
+    return this.accounts[account];
+  }
+
+  /**
+   * TODO
+   * Potrei organizzare in:
+   * - lendingPoolData
+   * - usersData
+   * - tvlData
+   * - ximxData
+   */
+
+  // Fetchers
+  public apolloFetcher = initializer.apolloFetcher;
+  public fetchLendingPools = initializer.fetchLendingPools;
+  public fetchLendingPoolsPast = initializer.fetchLendingPoolsPast;
+  public fetchPastVolume = initializer.fetchPastVolume;
+  public fetchCurrentVolumeAndReserves = initializer.fetchCurrentVolumeAndReserves;
+  public fetchImpermaxChefRewardRates = initializer.fetchImpermaxChefRewardRates;
+  public fetchUniswapAPR = initializer.fetchUniswapAPR;
+  public fetchBlockByTimestamp = initializer.fetchBlockByTimestamp;
+  public initializeLendingPoolsData = initializer.initializeLendingPoolsData;
+  public getLendingPoolsData = initializer.getLendingPoolsData;
+  public getLendingPoolData = initializer.getLendingPoolData;
+  public initializeTvlData = initializer.initializeTvlData;
+  public getTvlData = initializer.getTvlData;
+  public fetchUserData = initializer.fetchUserData;
+  public initializeUserData = initializer.initializeUserData;
+  public getUserData = initializer.getUserData;
+  public initializeXimxData = initializer.initializeXimxData;
+  public getXimxData = initializer.getXimxData;
+
+  /**
+   * DATA GETTERS
+   */
+
+  // Pair List
+  /*async getPairListOld() : Promise<FactoryIndex<Address[]>> {
+    const result: FactoryIndex<Address[]> = {};
+    const lendingPoolData = await this.getLendingPoolsData();
+    for (const factory of Object.keys(lendingPoolData) as Factory[]) {
+      result[factory] = Object.keys(lendingPoolData[factory]);
+    }
+    return result;
+  }
+    async getPairListWithData() {
+    const pairList = await this.getPairList();
+    if (!pairList) return null;
+    const requests = [];
+    for (const factory of Object.keys(pairList) as Factory[]) {
+      for (const pairAddress of pairList[factory]) {
+        requests.push(this.getPairData(factory, pairAddress));
+      }
+    }
+    console.log("length", requests.length)
+    return Promise.all(requests);
+  }*/
+  async getPairList() {
+    const result = [];
+    const lendingPoolData = await this.getLendingPoolsData();
+    for (const factory of Object.keys(lendingPoolData) as Factory[]) {
+      for (const pairAddress of Object.keys(lendingPoolData[factory])) {
+        result.push({pairAddress, factory});
+      }
+    }
+    return result;
+  }
+  private async getPairData(factory: Factory, pairAddress: Address) {
+    const lendingPool = await this.getLendingPool(factory, pairAddress);
+    const totalBorrowsUSD = await lendingPool.getTotalBorrowsUSD();
+    return {pairAddress, factory, totalBorrowsUSD};
+  }
+  async getPairListWithData(pairList: {
+    pairAddress: string;
+    factory: Factory;
+  }[]) {
+    const requests = [];
+    for (const pair of pairList) {
+      requests.push(this.getPairData(pair.factory, pair.pairAddress));
+    }
+    return Promise.all(requests);
+  }
+
+  // TVL Data
+  async getCrossChainTVL() : Promise<number> {
+    const tvlData = await this.getTvlData();
+    return tvlData.crossChainTVLUSD;
+  }
+  async getTotalValueLocked() : Promise<number> {
+    const tvlData = await this.getTvlData();
+    return tvlData.totalBalanceUSD;
+  }
+  async getTotalValueSupplied() : Promise<number> {
+    const tvlData = await this.getTvlData();
+    return tvlData.totalSupplyUSD;
+  }
+  async getTotalValueBorrowed() : Promise<number> {
+    const tvlData = await this.getTvlData();
+    return tvlData.totalBorrowsUSD;
+  }
+
+  // IMX Staking
+  async getXIMXAPY() : Promise<number> {
+    const ximxData = await this.getXimxData();
+    if (!ximxData) return 0;
+    return Math.pow(1 + parseFloat(ximxData.dailyAPR), 365) - 1;
+  }
+}

package/subgraph/initializer.ts

@@ -0,0 +1,509 @@
+import { LendingPoolData, TvlData, UserData, CollateralPosition, SupplyPosition, BorrowPosition, XimxData } from "../impermax-router/interfaces";
+import ApolloClient from "apollo-client";
+import { HttpLink } from "apollo-link-http";
+import { InMemoryCache } from "apollo-cache-inmemory";
+import Subgraph from ".";
+import { DocumentNode, } from "graphql";
+import * as query from "./query";
+import LendingPool from "./LendingPool";
+import {
+  BLOCKS_SUBGRAPH_URL,
+  IMPERMAX_CHEF_SUBGRAPH_URL,
+  IMPERMAX_SUBGRAPH_URL,
+  XIMX_SUBGRAPH_URL
+} from '../config/subgraphs';
+import {
+  Address,
+  AddressIndex, Amms,
+  Factory,
+  FactoryIndex,
+  LendingPoolIndex,
+  Networks,
+  PoolTokenType
+} from '../config/types';
+import { AMM_LP_FEE, AMM_SUBGRAPH_URLS, getAmmByFactory } from '../config/amms';
+
+const SECONDS_IN_YEAR = 60 * 60 * 24 * 365;
+
+export async function apolloFetcher(subgraphUrl: string, query: DocumentNode) {
+  const client = new ApolloClient({
+    link: new HttpLink({
+      uri: subgraphUrl,
+    }),
+    cache: new InMemoryCache(),
+  });
+  return client.query({
+    query: query,
+    fetchPolicy: 'cache-first',
+  });
+}
+
+export async function fetchBlockByTimestamp(this: Subgraph, timestamp: number) : Promise<number> {
+  const result = await this.apolloFetcher(
+    BLOCKS_SUBGRAPH_URL[this.network],
+    query.blockQuery(timestamp)
+  );
+  console.log(result.data._meta.block.number);
+  return result.data.blocks[0].number;
+}
+
+// Fetch Lending Pools
+export async function fetchLendingPools(this: Subgraph) : Promise<FactoryIndex<LendingPoolData[]>> {
+  const calls = [];
+  for (const factory of Object.keys(IMPERMAX_SUBGRAPH_URL[this.network]) as Factory[]) {
+    const subgraph = IMPERMAX_SUBGRAPH_URL[this.network][factory];
+    calls.push(this.apolloFetcher(subgraph, query.lendingPoolsQuery(factory, [])));
+  }
+  const results = await Promise.all(calls);
+  const lendingPools: FactoryIndex<LendingPoolData[]> = {};
+  let i = 0;
+  for (const factory of Object.keys(IMPERMAX_SUBGRAPH_URL[this.network])) {
+    lendingPools[factory as Factory] = results[i++].data.lendingPools;
+  }
+  return lendingPools;
+}
+export async function fetchLendingPoolsPast(this: Subgraph, seconds: number) : Promise<FactoryIndex<any[]>> {
+  const timestamp = Math.floor((new Date).getTime() / 1000);
+  const blockNumber = await this.fetchBlockByTimestamp(timestamp - seconds);
+  try {
+    const calls = [];
+    for (const factory of Object.keys(IMPERMAX_SUBGRAPH_URL[this.network]) as Factory[]) {
+      const subgraph = IMPERMAX_SUBGRAPH_URL[this.network][factory];
+      calls.push(this.apolloFetcher(subgraph, query.lendingPoolsPastQuery(blockNumber, this.whitelistedPairs[factory])));
+    }
+    const results = await Promise.all(calls);
+    const lendingPools: FactoryIndex<any[]> = {};
+    let i = 0;
+    for (const factory of Object.keys(IMPERMAX_SUBGRAPH_URL[this.network])) {
+      lendingPools[factory as Factory] = results[i++].data.lendingPools;
+    }
+    return lendingPools;
+  }
+  catch { return null }
+}
+
+// Farming APR
+
+export async function fetchImpermaxChefRewardRates(this: Subgraph) : Promise<AddressIndex<Array<{
+  rewardToken: Address, 
+  rewardRate: number
+}>>> {
+  if (!IMPERMAX_CHEF_SUBGRAPH_URL[this.network]) return null;
+  const result = await this.apolloFetcher(
+    IMPERMAX_CHEF_SUBGRAPH_URL[this.network], 
+    query.impermaxChefQuery()
+  );
+
+  const rewards: AddressIndex<Array<{
+    rewardToken: Address, 
+    rewardRate: number
+  }>> = {};
+  
+  let rewardToken = result.data.impermaxChefs[0].rewardToken;
+  let rewardPerSec = parseFloat(result.data.impermaxChefs[0].rewardPerSec);
+  let totalAllocPoint = parseFloat(result.data.impermaxChefs[0].totalAllocPoint);
+  const impermaxRewarders: Array<{
+    rewardToken: string,
+    rewardPerSec: string,
+    totalAllocPoint: string,
+    pools: Array<{
+      borrowable: string,
+      allocPoint: string,
+    }>
+  }> = result.data.impermaxRewarders;
+
+  for (const pool of result.data.pools) {
+    rewards[pool.id as Address] = [];
+    rewards[pool.id as Address].push({
+      rewardToken, 
+      rewardRate: parseFloat(pool.allocPoint) / totalAllocPoint * rewardPerSec
+    });
+  }
+
+  for (const impermaxRewarder of impermaxRewarders) {
+    rewardToken = impermaxRewarder.rewardToken;
+    rewardPerSec = parseFloat(impermaxRewarder.rewardPerSec);
+    totalAllocPoint = parseFloat(impermaxRewarder.totalAllocPoint);
+    for (const pool of impermaxRewarder.pools) {
+      if (!(pool.borrowable in rewards)) rewards[pool.borrowable] = []; 
+      rewards[pool.borrowable].push({
+        rewardToken, 
+        rewardRate: parseFloat(pool.allocPoint) / totalAllocPoint * rewardPerSec
+      });
+    }
+  }
+
+  return rewards;
+}
+
+// Uniswap APR
+
+export async function fetchPastVolume(this: Subgraph, amm: Amms, lendingPools: LendingPoolData[], seconds: number) : Promise<AddressIndex<number>> {
+  const timestamp = Math.floor((new Date).getTime() / 1000);
+  const blockNumber = await this.fetchBlockByTimestamp(timestamp - seconds);
+  let result;
+  const pastVolume: AddressIndex<number> = {};
+  try {
+    result = await this.apolloFetcher(
+      AMM_SUBGRAPH_URLS[this.network][amm], 
+      query.pastVolumeQuery(blockNumber, lendingPools.map(lendingPool => lendingPool.pair.uniswapV2PairAddress))
+    );
+    for (const pair of result.data.pairs) {
+      pastVolume[pair.id] = parseInt(pair.volumeUSD);
+    }
+  }
+  catch (e) {
+    console.error(e);
+  }
+  return pastVolume;
+}
+
+export async function fetchCurrentVolumeAndReserves(this: Subgraph, amm: Amms, lendingPools: LendingPoolData[]) : Promise<{
+  currentVolume: AddressIndex<number>, 
+  currentReserve: AddressIndex<number>,
+}> {
+  let result;
+  const currentVolume: AddressIndex<number> = {};
+  const currentReserve: AddressIndex<number> = {};
+  try {
+    result = await this.apolloFetcher(
+      AMM_SUBGRAPH_URLS[this.network][amm], 
+      query.currentVolumeAndReservesQuery(lendingPools.map(lendingPool => lendingPool.pair.uniswapV2PairAddress))
+    );
+    for (const pair of result.data.pairs) {
+      currentVolume[pair.id] = parseInt(pair.volumeUSD);
+      currentReserve[pair.id] = parseInt(pair.reserveUSD);
+    }
+  }
+  catch (e) {
+    console.error(e);
+  }
+  return { currentReserve, currentVolume };
+}
+
+export async function fetchUniswapAPR(this: Subgraph, lendingPoolsByAmm: {[key in Amms]?: LendingPoolData[]}, seconds: number = 60 * 60 * 24 * 7) : Promise<AddressIndex<number>> {
+  const uniswapAPR: AddressIndex<number> = {};
+  const amms = Object.keys(lendingPoolsByAmm) as Amms[];
+
+  const promises = [];
+  for (const amm of amms) {
+    if (!AMM_SUBGRAPH_URLS[this.network][amm]) continue;
+    promises.push(Promise.all([
+      amm,
+      this.fetchPastVolume(amm, lendingPoolsByAmm[amm], seconds),
+      this.fetchCurrentVolumeAndReserves(amm, lendingPoolsByAmm[amm]),
+    ]));
+  }
+
+  const ammsData = await Promise.all(promises);
+  for (const data of ammsData) {
+    const [
+      amm,
+      pastVolume,
+      { currentVolume, currentReserve },
+    ] = data;
+
+    for (const lendingPool of lendingPoolsByAmm[amm]) {
+      const uniswapV2PairAddress = lendingPool.pair.uniswapV2PairAddress;
+      if (!currentReserve[uniswapV2PairAddress]) {
+        uniswapAPR[lendingPool.id] = 0;
+        continue;
+      }
+      const cumVolumePast = pastVolume[uniswapV2PairAddress] ? pastVolume[uniswapV2PairAddress] : 0;
+      const cumVolumeNow = currentVolume[uniswapV2PairAddress];
+      const reserveUSD = currentReserve[uniswapV2PairAddress];
+      const volumeUSD = cumVolumeNow - cumVolumePast;
+      const yearlyVolume = volumeUSD * SECONDS_IN_YEAR / seconds;
+      const yearlyFee = yearlyVolume * AMM_LP_FEE[this.network][amm];
+      uniswapAPR[lendingPool.id] = yearlyFee / reserveUSD;
+    }
+  }
+  return uniswapAPR;
+}
+
+// LendingPool Data
+export async function initializeLendingPoolsData(this: Subgraph) : Promise<LendingPoolIndex<LendingPoolData>> {
+  const lendingPoolsData: LendingPoolIndex<LendingPoolData> = {};
+
+  // Get raw data
+  const [
+    lendingPools,
+    lendingPoolsPast24h,
+    lendingPoolsPast7d,
+    impermaxChefRewardRates,
+  ] = await Promise.all([
+    this.fetchLendingPools(),
+    this.fetchLendingPoolsPast(24 * 3600),
+    this.fetchLendingPoolsPast(7 * 24 * 3600),
+    this.fetchImpermaxChefRewardRates(),
+  ]);
+
+  // Get Uniswap APR
+  const lendingPoolsByAmm: {[key in Amms]?: LendingPoolData[]} = {};
+  for (const factory of Object.keys(lendingPools) as Factory[]) {
+    for (const lendingPool of lendingPools[factory]) {
+      const amm = getAmmByFactory(this.network, lendingPool.pair.uniswapV2Factory);
+      if (!amm) continue;
+      if (!lendingPoolsByAmm[amm]) lendingPoolsByAmm[amm] = [];
+      lendingPoolsByAmm[amm].push(lendingPool);
+    }
+  }
+  const uniswapAPR = await this.fetchUniswapAPR(lendingPoolsByAmm);
+
+  // Organize lending pools data
+  for (const factory of Object.keys(lendingPools) as Factory[]) {
+    for (const lendingPool of lendingPools[factory]) { 
+      lendingPool.pair.uniswapAPR = uniswapAPR[lendingPool.id] || 0;
+      if (impermaxChefRewardRates) {
+        lendingPool.borrowable0.rewards = impermaxChefRewardRates[lendingPool.borrowable0.id];
+        lendingPool.borrowable1.rewards = impermaxChefRewardRates[lendingPool.borrowable1.id];
+      }
+      // If one of the price of the 2 tokens is 0, fix the collateral price by doubling it
+      if (parseFloat(lendingPool.borrowable0.underlying.derivedUSD) === 0 || parseFloat(lendingPool.borrowable1.underlying.derivedUSD) === 0) {
+        lendingPool.pair.derivedUSD = (parseFloat(lendingPool.pair.derivedUSD) * 2).toString();
+      }
+      if (!lendingPoolsData[factory]) lendingPoolsData[factory] = {};
+      lendingPoolsData[factory][lendingPool.id] = lendingPool;
+    }
+    // Add past data
+    if (lendingPoolsPast24h && lendingPoolsPast24h[factory]) {
+      for (const lendingPool of lendingPoolsPast24h[factory]) {
+        lendingPoolsData[factory][lendingPool.id].past24h = lendingPool;
+      }
+    }
+    if (lendingPoolsPast7d && lendingPoolsPast7d[factory]) {
+      for (const lendingPool of lendingPoolsPast7d[factory]) {
+        lendingPoolsData[factory][lendingPool.id].past7d = lendingPool;
+      }
+    }
+  }
+
+  // Initialize LendingPool objects
+  this.lendingPools = {};
+  for (const factory of Object.keys(lendingPools) as Factory[]) {
+    this.lendingPools[factory] = {};
+    for (const lendingPool of lendingPools[factory]) {
+      this.lendingPools[factory][lendingPool.id] = new LendingPool(this, factory, lendingPool.id);
+    }
+  }
+
+
+  // Quickfix for MIM and SPELL
+  
+  if (this.network === Networks.Arbitrum) {
+    //const ETH_MIM = '0xa6e69dd0c36f3b59539e2c7afd274ef91b5c70f9';
+    //const ETH_SPELL = '0x35b44b303eacb71114aa62fe8dae6f9c5de0f680';
+    const ETH_gGOHM = '0x6d94f7e67c6ae0b0257c35754e059fdfb249d998';
+    const ETH_MAGIC = '0x88a0b00bbe918ee00e3482f71962070dc052984b';
+    const ETH_RDNT = '0xfb468ad210d427d65c9a765a480649d5754ca325';
+    if (lendingPoolsData[Factory.V2V1_1][ETH_gGOHM]) {
+      //lendingPoolsData[Factory.V2V1_1][ETH_SPELL].pair.rewards[0].rewardRate = '8.44';
+      //lendingPoolsData[Factory.V2V1_1][ETH_MIM].pair.rewards[0].rewardRate = '30.64';
+      //lendingPoolsData[Factory.V2V1_1][ETH_gGOHM].pair.rewards[0].rewardRate = '0.000009129';
+      lendingPoolsData[Factory.V2V1_1][ETH_MAGIC].pair.rewards[0].rewardRate = '0.135';
+    }
+    if (lendingPoolsData[Factory.V2V2][ETH_RDNT]) {
+      lendingPoolsData[Factory.V2V2][ETH_RDNT].pair.rewards[0].rewardRate = (parseFloat(lendingPoolsData[Factory.V2V2][ETH_RDNT].pair.rewards[0].rewardRate) / 2).toString();
+    }
+  }
+  
+  if (this.network === Networks.Polygon) {
+    const GNS_DAI = '0xf9221c5edc736d26ffc4ddccddfa15a4b958862e';
+    if (lendingPoolsData[Factory.V2V2][GNS_DAI]) {
+      const GNS = lendingPoolsData[Factory.V2V2][GNS_DAI].borrowable1.underlying;
+      lendingPoolsData[Factory.V2V2][GNS_DAI].pair.rewards[0] = {
+        id: '',
+        rewardsToken: GNS,
+        rewardRate: '0.00608',
+        periodFinish: '0',
+      };
+      lendingPoolsData[Factory.V2V2][GNS_DAI].pair.stakedTotalSupply = '1640000';
+    }
+  }
+
+  if (this.network === Networks.Avalanche) {
+    const QI_AVAX = '0x3e2a4dcd46e0e339aec603080d90bd939a163062';
+    if (lendingPoolsData[Factory.V2V1_2][QI_AVAX]) {
+      const QI = lendingPoolsData[Factory.V2V1_2][QI_AVAX].borrowable0.underlying;
+      lendingPoolsData[Factory.V2V1_2][QI_AVAX].pair.rewards[0] = {
+        id: '',
+        rewardsToken: QI,
+        rewardRate: '4.54',
+        periodFinish: '0',
+      };
+      // TODO -> this is wrong
+      lendingPoolsData[Factory.V2V1_2][QI_AVAX].pair.stakedTotalSupply = '0.000000992210460243'; //https://snowtrace.io/token/0xe530dc2095ef5653205cf5ea79f8979a7028065c?a=0x784da19e61cf348a8c54547531795ecfee2affd1
+    }
+    /*REWARD STOPPED const sAVAX_AVAX = '0x5b588f4481035b0f765393fc9f4752615a6d0498';
+    if (lendingPoolsData[Factory.V2V1_2][sAVAX_AVAX]) {
+      const QI = lendingPoolsData[Factory.V2V1_2][QI_AVAX].borrowable0.underlying;
+      lendingPoolsData[Factory.V2V1_2][sAVAX_AVAX].pair.rewards[1] = {
+        id: '',
+        rewardsToken: QI,
+        rewardRate: '1.74',
+        periodFinish: '0',
+      };
+    }
+    const UST_AVAX = '0xc6e68d77d0f4fa925a1cf2611dab6b10900eaf2b';
+    if (lendingPoolsData[Factory.V2V1_2][UST_AVAX]) {
+      const AVAX = lendingPoolsData[Factory.V2V1_2][UST_AVAX].borrowable1.underlying;
+      lendingPoolsData[Factory.V2V1_2][UST_AVAX].pair.rewards[0].rewardRate = '0.000099';
+      lendingPoolsData[Factory.V2V1_2][UST_AVAX].pair.rewards[2] = {
+        id: '',
+        rewardsToken: AVAX,
+        rewardRate: '0.00047',
+        periodFinish: '0',
+      };
+    }
+    const UST_USDC = '0x69c1c44e8742b66d892294a7eeb9aac51891b0eb';
+    if (lendingPoolsData[Factory.V2V1_2][UST_USDC]) {
+      const AVAX = lendingPoolsData[Factory.V2V1_2][UST_AVAX].borrowable1.underlying;
+      lendingPoolsData[Factory.V2V1_2][UST_USDC].pair.rewards[0].rewardRate = '0.000099';
+      lendingPoolsData[Factory.V2V1_2][UST_USDC].pair.rewards[2] = {
+        id: '',
+        rewardsToken: AVAX,
+        rewardRate: '0.00047',
+        periodFinish: '0',
+      };
+    }*/
+  }
+
+  return lendingPoolsData;
+}
+export async function getLendingPoolsData(this: Subgraph) : Promise<LendingPoolIndex<LendingPoolData>> {
+  if (!this.lendingPoolsData) this.lendingPoolsData = this.initializeLendingPoolsData();
+  return this.lendingPoolsData;
+}
+export async function getLendingPoolData(this: Subgraph, factory: Factory, uniswapV2PairAddress: Address) : Promise<LendingPoolData> {
+  return (await this.getLendingPoolsData())[factory][uniswapV2PairAddress.toLowerCase()];
+}
+
+// TVL Data
+export async function initializeTvlData(this: Subgraph) : Promise<TvlData> {
+  const networks: Networks[] = [
+    Networks.Mainnet, 
+    Networks.Arbitrum, 
+    Networks.Polygon, 
+    Networks.Avalanche, 
+    Networks.Moonriver, 
+    Networks.Fantom
+  ]; // exclude ropsten
+  const calls = [];
+  for (const network of networks) {
+    for (const factory of Object.keys(IMPERMAX_SUBGRAPH_URL[network])) {
+      const subgraph = IMPERMAX_SUBGRAPH_URL[network][factory as Factory];
+      calls.push(this.apolloFetcher(subgraph, query.tvlQuery()));
+    }
+  }
+  const results = await Promise.all(calls);
+  let crossChainTVLUSD = 0;
+  let thisChainTVLUSD = 0;
+  let thisChainSupplyUSD = 0;
+  let thisChainBorrowUSD = 0;
+  let i = 0;
+  for (const network of networks) {
+    let chainTvlUSD = 0;
+    for (const factory of Object.keys(IMPERMAX_SUBGRAPH_URL[network])) {
+      const data = results[i].data.impermaxFactories[0];
+      chainTvlUSD += parseFloat(data.totalBalanceUSD);
+      if (network === this.network) {
+        thisChainTVLUSD += parseFloat(data.totalBalanceUSD);
+        thisChainSupplyUSD += parseFloat(data.totalSupplyUSD);
+        thisChainBorrowUSD += parseFloat(data.totalBorrowsUSD);
+      }
+      i++;
+    }
+    crossChainTVLUSD += chainTvlUSD;
+  }
+  return {
+    crossChainTVLUSD,
+    totalBalanceUSD: thisChainTVLUSD,
+    totalSupplyUSD: thisChainSupplyUSD,
+    totalBorrowsUSD: thisChainBorrowUSD,
+  };
+}
+export async function getTvlData(this: Subgraph) : Promise<TvlData> {
+  if (!this.tvlData) this.tvlData = this.initializeTvlData();
+  return this.tvlData;
+}
+
+// User Data
+export async function fetchUserData(this: Subgraph, account: Address) : Promise<FactoryIndex<{
+  collateralPositions: CollateralPosition[],
+  supplyPositions: SupplyPosition[],
+  borrowPositions: BorrowPosition[],
+}>> {
+  const positions: FactoryIndex<{
+    collateralPositions: CollateralPosition[],
+    supplyPositions: SupplyPosition[],
+    borrowPositions: BorrowPosition[],
+  }> = {};
+  for (const factory of Object.keys(IMPERMAX_SUBGRAPH_URL[this.network]) as Factory[]) {
+    const subgraph = IMPERMAX_SUBGRAPH_URL[this.network][factory];
+    const result = await this.apolloFetcher(subgraph, query.userQuery(account));
+    const user = result.data.user;
+    if (!user) continue;
+    positions[factory as Factory] = {
+      collateralPositions: user.collateralPositions,
+      supplyPositions: user.supplyPositions,
+      borrowPositions: user.borrowPositions,
+    }
+  }
+  return positions;
+
+  // TODO parallelize calls
+}
+export async function initializeUserData(this: Subgraph, account: Address) : Promise<FactoryIndex<UserData>> {
+  const result: FactoryIndex<UserData> = {};
+  const userData = await this.fetchUserData(account);
+  if (!userData) return null;
+  for (const factory of Object.keys(userData) as Factory[]) {
+    result[factory] = {
+      collateralPositions: {},
+      supplyPositions: {},
+      borrowPositions: {},
+    };
+    const data = userData[factory];
+    for (const collateralPosition of data.collateralPositions) {
+      result[factory].collateralPositions[collateralPosition.collateral.lendingPool.id] = collateralPosition;
+    }
+    for (const supplyPositions of data.supplyPositions) {
+      const uniswapV2PairAddress = supplyPositions.borrowable.lendingPool.id;
+      const underlyingAddress = supplyPositions.borrowable.underlying.id;
+      const borrowableA = (await this.getLendingPool(factory, uniswapV2PairAddress)).poolTokens[PoolTokenType.BorrowableA];
+      const addressA = await borrowableA.getUnderlyingAddress();
+      const poolTokenType = underlyingAddress === addressA ? PoolTokenType.BorrowableA : PoolTokenType.BorrowableB;
+      if (!(uniswapV2PairAddress in result[factory].supplyPositions)) result[factory].supplyPositions[uniswapV2PairAddress] = {};
+      result[factory].supplyPositions[uniswapV2PairAddress][poolTokenType] = supplyPositions;
+    }
+    for (const borrowPositions of data.borrowPositions) {
+      const uniswapV2PairAddress = borrowPositions.borrowable.lendingPool.id;
+      const underlyingAddress = borrowPositions.borrowable.underlying.id;
+      const borrowableA = (await this.getLendingPool(factory, uniswapV2PairAddress)).poolTokens[PoolTokenType.BorrowableA];
+      const addressA = await borrowableA.getUnderlyingAddress();
+      const poolTokenType = underlyingAddress === addressA ? PoolTokenType.BorrowableA : PoolTokenType.BorrowableB;
+      if (!(uniswapV2PairAddress in result[factory].borrowPositions)) result[factory].borrowPositions[uniswapV2PairAddress] = {};
+      result[factory].borrowPositions[uniswapV2PairAddress][poolTokenType] = borrowPositions;
+    }
+  }
+  return result;
+}
+export async function getUserData(this: Subgraph, account: Address) : Promise<FactoryIndex<UserData>> {
+  if (!(account in this.usersData)) this.usersData[account] = this.initializeUserData(account);
+  return this.usersData[account];
+}
+
+// IMX Staking
+
+export async function initializeXimxData(this: Subgraph): Promise<XimxData> {
+  const result = await apolloFetcher(
+    XIMX_SUBGRAPH_URL, 
+    query.ximxQuery()
+  );
+
+  return result.data.ximxes[0];
+}
+export async function getXimxData(this: Subgraph): Promise<XimxData> {
+  if (!this.ximxData) this.ximxData = this.initializeXimxData();
+  return this.ximxData;
+}