@aurigami/sdk 1.23.1 → 1.24.1

package/src/helpers/historicalPriceFetcher.ts

@@ -1,203 +0,0 @@
-import { IUniswapV2Pair, PriceOracle } from '@aurigami/contracts/typechain';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract, providers } from 'ethers';
-import { AuriOracleABI, IUniswapV2PairABI } from '../abis';
-import { HARDCODE_PRICE_TOKENS, networkAddresses } from '../consts/constants';
-import { Address } from '../types';
-import { decimalFactor, devLog, getDecimal, isSameAddress } from './helpers';
-
-export async function fetchHistoricalLPPositions(
-  LPAddress: Address,
-  provider: providers.Provider,
-  block: number
-): Promise<{
-  token0: Address;
-  token1: Address;
-  reserve0: BN;
-  reserve1: BN;
-  totalSupply: BN;
-}> {
-  const LPContract = new Contract(LPAddress, IUniswapV2PairABI.abi, provider) as IUniswapV2Pair;
-  var promises: any[] = [];
-  promises.push(LPContract.token0());
-  promises.push(LPContract.token1());
-  promises.push(LPContract.getReserves({ blockTag: block }));
-  promises.push(LPContract.totalSupply({ blockTag: block }));
-  const values: any[] = await Promise.all(promises);
-
-  return {
-    token0: values[0] as string,
-    token1: values[1] as string,
-    reserve0: (values[2] as { reserve0: BN; reserve1: BN }).reserve0,
-    reserve1: (values[2] as { reserve0: BN; reserve1: BN }).reserve1,
-    totalSupply: values[3] as BN,
-  };
-}
-
-export async function fetchHistoricalLPPrice(
-  address: Address,
-  provider: providers.Provider,
-  block: number
-): Promise<BigNumber> {
-  var LPInfo = await fetchHistoricalLPPositions(address, provider, block);
-  const LPDecimal = getDecimal(address);
-
-  async function fetchLPPriceBy(
-    tokenReverse: {
-      address: string;
-      reserve: BN;
-    },
-    block: number
-  ): Promise<BigNumber> {
-    if (tokenReverse.reserve.isZero()) return new BigNumber(0);
-
-    const tokenPrice: BigNumber = await fetchHistoricalPrice(tokenReverse.address, provider, block);
-    const tokenDecimal = getDecimal(tokenReverse.address);
-
-    // reserveUSD will be divided by 10^tokenDecimal later for more precision
-    const reserveUSD: BigNumber = tokenPrice
-      .multipliedBy(tokenReverse.reserve.toString())
-      .multipliedBy(2);
-    return reserveUSD
-      .multipliedBy(decimalFactor(LPDecimal))
-      .dividedBy(new BigNumber(LPInfo.totalSupply.toString()))
-      .dividedBy(decimalFactor(tokenDecimal));
-  }
-
-  try {
-    // MUST await here
-    const lpPrice = await fetchLPPriceBy(
-      {
-        address: LPInfo.token0,
-        reserve: LPInfo.reserve0,
-      },
-      block
-    );
-    if (lpPrice.isZero()) {
-      throw Error(`Price is zero`);
-    }
-    return lpPrice;
-  } catch (e) {
-    devLog(`fetchLPPriceBy ${LPInfo.token0} failed`, e);
-    try {
-      // MUST await here
-      return await fetchLPPriceBy(
-        {
-          address: LPInfo.token1,
-          reserve: LPInfo.reserve1,
-        },
-        block
-      );
-    } catch (e) {
-      devLog(`fetchLPPriceBy ${LPInfo.token1} failed`, e);
-      throw Error(`Unable to fetch price for both tokens of LP ${address}`);
-    }
-  }
-}
-
-function processPriceFromOracle(rawPrice: BN, underlyingDecimal: number) {
-  return new BigNumber(rawPrice.toString()).div(decimalFactor(36 - underlyingDecimal));
-}
-export async function fetchHistoricalPriceFromOracle(
-  auTokenAddress: Address,
-  underlyingDecimal: number,
-  provider: providers.Provider,
-  block: number
-): Promise<BigNumber> {
-  // from this block, we switch to use pyth
-  // TODO: add to consts
-  const oracleAddress =
-    block < 102438637
-      ? networkAddresses.misc.DEPRECATED_OLD_ORACLE
-      : networkAddresses.misc.PYTH_ORACLE;
-
-  const oracleContract: PriceOracle = new Contract(
-    oracleAddress,
-    AuriOracleABI.abi,
-    provider
-  ) as PriceOracle;
-  const rawPrice = await oracleContract
-    .getUnderlyingPrice(auTokenAddress, { blockTag: block })
-    .catch((e: any) => {
-      console.log(`Unable to fetch price from oracle for ${auTokenAddress}`);
-      return BN.from(0);
-    });
-
-  return processPriceFromOracle(rawPrice, underlyingDecimal);
-}
-
-export async function fetchHistoricalPrice(
-  address: Address,
-  provider: providers.Provider,
-  block: number
-): Promise<BigNumber> {
-  if (address.toLowerCase() in HARDCODE_PRICE_TOKENS) {
-    return new BigNumber(HARDCODE_PRICE_TOKENS[address.toLowerCase()]);
-  } else if (
-    isSameAddress(address, networkAddresses.tokens.PLY_WNEAR) ||
-    isSameAddress(address, networkAddresses.tokens.WNEAR_TRI) ||
-    isSameAddress(address, networkAddresses.tokens.AURORA_WNEAR)
-  ) {
-    return fetchHistoricalLPPrice(address, provider, block);
-  } else if (isSameAddress(address, networkAddresses.tokens.PLY)) {
-    return fetchHistoricalPriceByLP(networkAddresses.tokens.PLY_WNEAR, provider, block);
-  } else if (isSameAddress(address, networkAddresses.tokens.TRI)) {
-    return fetchHistoricalPriceByLP(networkAddresses.tokens.WNEAR_TRI, provider, block, 1);
-  } else if (isSameAddress(address, networkAddresses.tokens.AURORA)) {
-    return fetchHistoricalPriceByLP(networkAddresses.tokens.AURORA_WNEAR, provider, block);
-  }
-
-  const matchingAuToken = networkAddresses.auTokens.find((auToken) => {
-    return isSameAddress(auToken.underlying, address);
-  });
-
-  if (matchingAuToken !== undefined) {
-    return fetchHistoricalPriceFromOracle(
-      matchingAuToken.address,
-      getDecimal(address),
-      provider,
-      block
-    );
-  } else {
-    throw Error(`Unable to fetch price for ${address}`);
-  }
-}
-
-export async function fetchHistoricalPULPPrice(provider: providers.Provider): Promise<BigNumber> {
-  //TODO: Calculate PULP price
-  return new BigNumber(0);
-}
-
-export async function fetchHistoricalPriceByLP(
-  LP: Address,
-  provider: providers.Provider,
-  block: number,
-  tokenNumber: 0 | 1 = 0
-): Promise<BigNumber> {
-  let LPInfo = await fetchHistoricalLPPositions(LP, provider, block);
-
-  if (tokenNumber === 1) {
-    LPInfo = {
-      token0: LPInfo.token1,
-      token1: LPInfo.token0,
-      reserve0: LPInfo.reserve1,
-      reserve1: LPInfo.reserve0,
-      totalSupply: LPInfo.totalSupply,
-    };
-  }
-
-  if (LPInfo.reserve1.isZero()) {
-    return new BigNumber(0);
-  }
-
-  const token0Decimal = getDecimal(LPInfo.token0);
-  const token1Decimal = getDecimal(LPInfo.token1);
-
-  // (token0Price * reserve0) / 10^decimal0 = (token1Price * reserve1) / 10^decimal1
-  // token0Price = (token1Price * reserve1) * 10^decimal0 / 10^decimal1  / reserve0
-  return (await fetchHistoricalPrice(LPInfo.token1, provider, block))
-    .multipliedBy(LPInfo.reserve1.toString())
-    .multipliedBy(decimalFactor(token0Decimal))
-    .dividedBy(decimalFactor(token1Decimal))
-    .dividedBy(LPInfo.reserve0.toString());
-}

package/src/helpers/index.ts

@@ -1,7 +0,0 @@
-export * from './aurigami-api';
-export * from './aurora-api-helpers';
-export * from './graphql-helpers';
-export * from './helpers';
-export * from './priceFetcher';
-export * from './transfer-event-query';
-export * from './historicalPriceFetcher';

package/src/helpers/kyber-aggregator-api.ts

@@ -1,37 +0,0 @@
-import axios from 'axios';
-
-const KYBER_AGGREGATOR_AURORA_API_END_POINT =
-  'https://aggregator-api.kyberswap.com/aurora/route/encode';
-
-const KYBER_AGGREGATOR_ETH_API_END_POINT =
-  'https://aggregator-api.kyberswap.com/ethereum/route/encode';
-
-export async function getSwapInfo(
-  tokenIn: string,
-  tokenOut: string,
-  amountIn: string,
-  onAurora = true
-): Promise<KyberApiResponse> {
-  const params = {
-    tokenIn,
-    tokenOut,
-    amountIn,
-    to: '0x0000000000000000000000000000000000000000',
-    useMeta: '1',
-    saveGas: '1',
-    gasInclude: '1',
-  };
-  const endpoint = onAurora
-    ? KYBER_AGGREGATOR_AURORA_API_END_POINT
-    : KYBER_AGGREGATOR_ETH_API_END_POINT;
-  const resp = await axios.get(endpoint + '?' + new URLSearchParams(params), {
-    headers: { 'Content-Type': 'application/json' },
-  });
-
-  return resp.data;
-}
-
-export type KyberApiResponse = {
-  inputAmount: string;
-  outputAmount: string;
-};

package/src/helpers/notification-api.ts

@@ -1,22 +0,0 @@
-import axios from 'axios';
-
-const NOTIFICATION_API_END_POINT = 'https://api.aurigami.finance/notification/';
-
-export async function getApi(url: string, params: Record<string, any> = {}): Promise<any> {
-  const resp = await axios.get(
-    NOTIFICATION_API_END_POINT + url + '?' + new URLSearchParams(params),
-    {
-      headers: { 'Content-Type': 'application/json' },
-    }
-  );
-
-  return resp.data;
-}
-
-export async function postApi(url: string, body: Record<string, any>): Promise<any> {
-  const resp = await axios.post(NOTIFICATION_API_END_POINT + url, body, {
-    headers: { 'Content-Type': 'application/json' },
-  });
-
-  return resp.data;
-}

package/src/helpers/one-inch-aggregator-api.ts

@@ -1,45 +0,0 @@
-// https://api.1inch.io/v5.0/1313161554/quote?fromTokenAddress=0x8bec47865ade3b172a928df8f990bc7f2a3b9f79&toTokenAddress=0x4988a896b1227218e4a686fde5eabdcabd91571f&amount=1000000000000000000
-
-import axios from 'axios';
-
-const ONEINCH_AGGREGATOR_API_END_POINT = 'https://api.1inch.io/v5.0/1313161554/quote';
-
-export async function getQuoteOneInch(
-  fromTokenAddress: string,
-  toTokenAddress: string,
-  amount: string
-): Promise<OneInchApiResponse> {
-  const params = {
-    fromTokenAddress,
-    toTokenAddress,
-    amount,
-  };
-  const resp = await axios.get(
-    ONEINCH_AGGREGATOR_API_END_POINT + '?' + new URLSearchParams(params),
-    {
-      headers: { 'Content-Type': 'application/json' },
-    }
-  );
-  return resp.data;
-}
-
-export type OneInchApiResponse = {
-  fromToken: {
-    symbol: string;
-    name: string;
-    decimals: number;
-    address: string;
-    logoURI: string;
-    tags: string[];
-  };
-  toToken: {
-    symbol: string;
-    name: string;
-    decimals: number;
-    address: string;
-    logoURI: string;
-    tags: string[];
-  };
-  toTokenAmount: string;
-  fromTokenAmount: string;
-};

package/src/helpers/priceFetcher.ts

@@ -1,389 +0,0 @@
-import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
-import { AuriPythOracle, ERC20, IUniswapV2Pair } from '@aurigami/contracts/typechain';
-import axios from 'axios';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract, ethers, providers } from 'ethers';
-import { AuriOracleABI, EIP20InterfaceABI, IUniswapV2PairABI } from '../abis';
-import {
-  DECIMAL_PRECISION,
-  HARDCODE_PRICE_TOKENS,
-  PRICE_WHITELISTED,
-  STADER_ETH,
-  USDT_ETH,
-  networkAddresses,
-} from '../consts/constants';
-import { TokenAmount } from '../entities/tokenAmount';
-import { Address, TokenValuation } from '../types';
-import { assert, decimalFactor, devLog, getDecimal, isSameAddress } from './helpers';
-import { getSwapInfo } from './kyber-aggregator-api';
-import { getQuoteOneInch } from './one-inch-aggregator-api';
-
-export async function prepareParamsAggregator(address: string, provider: providers.Provider) {
-  const tokenInErc20 = new Contract(address, EIP20InterfaceABI.abi, provider) as ERC20;
-  const tokenInDecimal = await tokenInErc20.decimals();
-  const tokenInQuantity = BN.from(10).pow(tokenInDecimal).toString();
-  const usdtAddress =
-    networkAddresses.auTokens.find((autoken) => autoken.name == 'auUSDT')?.underlying ?? '';
-  const usdtDecimal = getDecimal(usdtAddress);
-  return {
-    tokenInQuantity,
-    usdtAddress,
-    usdtDecimal,
-  };
-}
-
-export async function fetchPriceFromOneInch(address: string, provider: providers.Provider) {
-  const { tokenInQuantity, usdtAddress, usdtDecimal } = await prepareParamsAggregator(
-    address,
-    provider
-  );
-  const info = await getQuoteOneInch(address, usdtAddress, tokenInQuantity);
-  const outputAmount = info.toTokenAmount;
-  return new BigNumber(outputAmount).dividedBy(10 ** usdtDecimal);
-}
-
-export async function fetchPriceFromKyberSwap(
-  address: string,
-  provider: providers.Provider,
-  onAurora = true
-): Promise<BigNumber> {
-  if (address == networkAddresses.tokens.STADER) {
-    const ETH_PROVIDER = new ethers.providers.JsonRpcProvider('https://rpc.ankr.com/eth');
-
-    return fetchPriceFromKyberSwap(STADER_ETH, ETH_PROVIDER, false);
-  }
-  let { tokenInQuantity, usdtAddress, usdtDecimal } = await prepareParamsAggregator(
-    address,
-    provider
-  );
-  if (!onAurora) {
-    usdtAddress = USDT_ETH;
-  }
-  const info = await getSwapInfo(address, usdtAddress, tokenInQuantity, onAurora);
-  const outputAmount = info.outputAmount;
-  return new BigNumber(outputAmount).dividedBy(10 ** usdtDecimal);
-}
-
-export async function fetchPriceFromDefiLlamaAPI(id: string): Promise<BigNumber> {
-  const price = await axios
-    .get(`https://coins.llama.fi/prices/current/${id}`)
-    .then((res: any) => {
-      return res.data.coins[id].price;
-    })
-    .catch((err: any) => {
-      console.log(`unable to fetch price from DefiLlama API: ${err}`);
-      console.error(err);
-      return 0;
-    });
-  return new BigNumber(price);
-}
-
-export async function fetchPriceFromCoingeckoAPI(id: string): Promise<BigNumber> {
-  const price = await axios
-    .get(`https://api.coingecko.com/api/v3/simple/price?ids=${id}&vs_currencies=usd`)
-    .then((res: any) => {
-      return res.data[id];
-    })
-    .catch((err: any) => {
-      console.log(`Unable to fetch price from Coingecko API for ${id}`);
-      console.error(err);
-      return { usd: 0 };
-    });
-
-  return new BigNumber(price.usd);
-}
-
-export async function fetchPriceFromDefiLlamaAndCoingecko(id: Address): Promise<BigNumber> {
-  if (
-    id.toLowerCase() == networkAddresses.tokens.AURORA ||
-    id.toLowerCase() == networkAddresses.tokens.TRI ||
-    id.toLowerCase() == networkAddresses.tokens.META
-  ) {
-    return fetchPriceFromDefiLlamaAPI(`aurora:${id.toLowerCase()}`).catch((e) =>
-      fetchPriceFromCoingecko(id)
-    );
-  } else if (id.toLowerCase() == networkAddresses.tokens.STADER) {
-    return fetchPriceFromCoingecko(id);
-  }
-  throw Error(`Unknown token ${id} in fetchPriceFromDefiLlama`);
-}
-
-export async function fetchPriceFromCoingecko(id: Address): Promise<BigNumber> {
-  switch (id.toLowerCase()) {
-    case networkAddresses.tokens.AURORA:
-      return fetchPriceFromCoingeckoAPI('aurora-near');
-
-    case networkAddresses.tokens.TRI:
-      return fetchPriceFromCoingeckoAPI('trisolaris');
-
-    case networkAddresses.tokens.META:
-      return fetchPriceFromCoingeckoAPI('meta-pool');
-
-    case networkAddresses.tokens.STADER:
-      return fetchPriceFromCoingeckoAPI('stader');
-
-    default:
-      throw Error(`Unknown token ${id} in fetchPriceFromCoingecko`);
-  }
-}
-
-export async function fetchLPPositions(
-  LPAddress: Address,
-  provider: providers.Provider
-): Promise<{
-  token0: Address;
-  token1: Address;
-  reserve0: BN;
-  reserve1: BN;
-  totalSupply: BN;
-}> {
-  const LPContract = new Contract(LPAddress, IUniswapV2PairABI.abi, provider) as IUniswapV2Pair;
-  const [token0, token1, reserves, totalSupply] = await Promise.all([
-    LPContract.token0(),
-    LPContract.token1(),
-    LPContract.getReserves(),
-    LPContract.totalSupply(),
-  ]);
-
-  return {
-    token0: token0,
-    token1: token1,
-    reserve0: reserves.reserve0,
-    reserve1: reserves.reserve1,
-    totalSupply: totalSupply,
-  };
-}
-
-export async function fetchLPPrice(
-  address: Address,
-  provider: providers.Provider
-): Promise<BigNumber> {
-  var LPInfo = await fetchLPPositions(address, provider);
-  const LPDecimal = getDecimal(address);
-
-  async function fetchLPPriceBy(tokenReverse: {
-    address: string;
-    reserve: BN;
-  }): Promise<BigNumber> {
-    if (tokenReverse.reserve.isZero()) return new BigNumber(0);
-
-    // Should NOT call `fetchPrice`, it will cause an infinite loop
-    // because the token can be PLY. To calculate PLY price, we need to
-    // call `fetchPrice` again...
-    const tokenPrice: BigNumber = await _fetchPrice(tokenReverse.address, provider);
-    const tokenDecimal = getDecimal(tokenReverse.address);
-
-    // reserveUSD will be divided by 10^tokenDecimal later for more precision
-    const reserveUSD: BigNumber = tokenPrice
-      .multipliedBy(tokenReverse.reserve.toString())
-      .multipliedBy(2);
-    return reserveUSD
-      .multipliedBy(decimalFactor(LPDecimal))
-      .dividedBy(new BigNumber(LPInfo.totalSupply.toString()))
-      .dividedBy(decimalFactor(tokenDecimal));
-  }
-
-  try {
-    // MUST await here
-    const lpPrice = await fetchLPPriceBy({
-      address: LPInfo.token0,
-      reserve: LPInfo.reserve0,
-    });
-    if (lpPrice.isZero()) {
-      throw Error(`Price is zero`);
-    }
-    return lpPrice;
-  } catch (e) {
-    devLog(`fetchLPPriceBy ${LPInfo.token0} failed`, e);
-    try {
-      // MUST await here
-      return await fetchLPPriceBy({
-        address: LPInfo.token1,
-        reserve: LPInfo.reserve1,
-      });
-    } catch (e) {
-      devLog(`fetchLPPriceBy ${LPInfo.token1} failed`, e);
-      throw Error(`Unable to fetch price for both tokens of LP ${address}`);
-    }
-  }
-}
-
-export async function fetchStNEARPrice(): Promise<BigNumber> {
-  const ratioPromise = axios
-    .get('https://validators.narwallets.com/metrics_json')
-    .then((res) => res.data);
-  const nearPricePromise = fetchPriceFromCoingeckoAPI('near');
-  const [ratioRes, nearPrice]: [any, BigNumber] = await Promise.all([
-    ratioPromise,
-    nearPricePromise,
-  ]);
-  const ratio = new BigNumber(ratioRes.st_near_price);
-  return ratio.multipliedBy(nearPrice);
-}
-
-function processPriceFromOracle(rawPrice: BN, underlyingDecimal: number) {
-  return new BigNumber(rawPrice.toString()).div(decimalFactor(36 - underlyingDecimal));
-}
-export async function fetchPriceFromOracle(
-  auTokenAddress: Address,
-  underlyingDecimal: number,
-  provider: providers.Provider
-): Promise<BigNumber> {
-  const oracleContract: AuriPythOracle = new Contract(
-    networkAddresses.misc.PYTH_ORACLE,
-    AuriOracleABI.abi,
-    provider
-  ) as AuriPythOracle;
-  const rawPrice = await oracleContract.getUnderlyingPrice(auTokenAddress).catch((e: any) => {
-    console.log(`Unable to fetch price from oracle for ${auTokenAddress}`);
-    return BN.from(0);
-  });
-
-  // In case of error, probally it is because the underlying token is not supported
-  // by the backup oracle. In that case, we will fetch from third-party.
-  if (rawPrice.isZero()) {
-    const matchingAuToken = networkAddresses.auTokens.find((auToken) => {
-      return isSameAddress(auToken.address, auTokenAddress);
-    });
-    if (matchingAuToken?.name == 'auSTNEAR') {
-      return fetchStNEARPrice();
-    }
-  }
-
-  return processPriceFromOracle(rawPrice, underlyingDecimal);
-}
-
-export async function fetchUnderlyingTokensPrices(provider: providers.Provider): Promise<
-  {
-    auToken: string;
-    underlyingPrice: BigNumber;
-  }[]
-> {
-  const auriLens: Contract = new Contract(
-    networkAddresses.misc.AURILENS,
-    AuriLensABI.abi,
-    provider
-  );
-  const auTokenAddresses = networkAddresses.auTokens.map((auToken) => auToken.address);
-  const underlyingDecimals = networkAddresses.auTokens.map((auToken) =>
-    getDecimal(auToken.underlying)
-  );
-  const rawPrices = await auriLens.auTokenUnderlyingPriceAll(auTokenAddresses);
-  return rawPrices.map((res: any, ind: number) => {
-    return {
-      auToken: res.auToken,
-      underlyingPrice: processPriceFromOracle(res.underlyingPrice, underlyingDecimals[ind]),
-    };
-  });
-}
-
-function shouldFetchFromKyberSwap(address: string) {
-  address = address.toLowerCase();
-  return (
-    address == networkAddresses.tokens.TRI ||
-    address == networkAddresses.tokens.META ||
-    address == networkAddresses.tokens.STADER
-  );
-}
-
-/**
- * Fetch price from Oracle or Coingecko
- */
-async function _fetchPrice(address: Address, provider: providers.Provider): Promise<BigNumber> {
-  assert(
-    PRICE_WHITELISTED.has(address.toLocaleLowerCase()),
-    `Address ${address} is not whitelisted for price fetching`
-  );
-  if (address.toLowerCase() == networkAddresses.tokens.META) {
-    return fetchPriceFromDefiLlamaAndCoingecko(address);
-  }
-  if (shouldFetchFromKyberSwap(address)) {
-    return fetchPriceFromKyberSwap(address, provider).catch((e) => {
-      return fetchPriceFromDefiLlamaAndCoingecko(address);
-    });
-  }
-  const matchingAuToken = networkAddresses.auTokens.find((auToken) => {
-    return isSameAddress(auToken.underlying, address);
-  });
-
-  if (matchingAuToken !== undefined) {
-    return fetchPriceFromOracle(matchingAuToken.address, getDecimal(address), provider);
-  } else {
-    throw Error(`Unable to fetch price for ${address}`);
-  }
-}
-
-export async function fetchPrice(
-  address: Address,
-  provider: providers.Provider
-): Promise<BigNumber> {
-  if (address.toLowerCase() in HARDCODE_PRICE_TOKENS) {
-    return new BigNumber(HARDCODE_PRICE_TOKENS[address.toLowerCase()]);
-  } else if (isSameAddress(address, networkAddresses.tokens.PLYWNEAR)) {
-    return fetchLPPrice(address, provider);
-  } else if (isSameAddress(address, networkAddresses.tokens.PLY)) {
-    return fetchPLYPrice(provider);
-  } else if (isSameAddress(address, networkAddresses.tokens.PULP)) {
-    return fetchPULPPrice(provider);
-  }
-  return _fetchPrice(address, provider);
-}
-
-export async function fetchPLYPrice(provider: providers.Provider): Promise<BigNumber> {
-  //TODO: Fetch PLY price from CEX?
-  return fetchToken0PriceByLP(networkAddresses.tokens.PLYWNEAR, provider);
-}
-
-export async function fetchPULPPrice(provider: providers.Provider): Promise<BigNumber> {
-  //TODO: Calculate PULP price
-  return new BigNumber(0);
-}
-
-export async function fetchToken0PriceByLP(
-  LP: Address,
-  provider: providers.Provider
-): Promise<BigNumber> {
-  const LPInfo = await fetchLPPositions(LP, provider);
-
-  if (LPInfo.reserve1.isZero()) {
-    return new BigNumber(0);
-  }
-
-  const token0Decimal = getDecimal(LPInfo.token0);
-  const token1Decimal = getDecimal(LPInfo.token1);
-
-  // (token0Price * reserve0) / 10^decimal0 = (token1Price * reserve1) / 10^decimal1
-  // token0Price = (token1Price * reserve1) * 10^decimal0 / 10^decimal1  / reserve0
-  return (await fetchPrice(LPInfo.token1, provider))
-    .multipliedBy(LPInfo.reserve1.toString())
-    .multipliedBy(decimalFactor(token0Decimal))
-    .dividedBy(decimalFactor(token1Decimal))
-    .dividedBy(LPInfo.reserve0.toString());
-}
-
-export async function fetchValuation(
-  tokenAmount: TokenAmount,
-  provider: providers.Provider
-): Promise<BigNumber> {
-  if (tokenAmount.rawAmount() == '0') return new BigNumber(0);
-  var price = await fetchPrice(tokenAmount.token.address, provider);
-  return calcValuation(tokenAmount, price);
-}
-
-export function calcValuation(tokenAmount: TokenAmount, price: BigNumber) {
-  return new BigNumber(tokenAmount.formattedAmount()).multipliedBy(price);
-}
-
-export async function valuateToken(
-  tokenAmount: TokenAmount,
-  provider: providers.Provider
-): Promise<TokenValuation> {
-  let tokenValuation = await fetchValuation(tokenAmount, provider);
-  return {
-    tokenAmount: tokenAmount,
-    currencyAmount: {
-      currency: 'USD',
-      amount: tokenValuation.toFixed(DECIMAL_PRECISION),
-    },
-  };
-}