@aurigami/sdk 1.5.0-dummy → 1.5.0-dummy-2

package/src/priceFetcher.ts

@@ -1,212 +1,298 @@
-import BigNumber from "bignumber.js";
-import { Contract, providers, BigNumber as BN, ethers } from "ethers";
-import { DECIMAL_PRECISION, networkAddresses, PRICE_WHITELISTED } from "./constants";
-import OracleABI from "./abis/Oracle.json";
-import { isSameAddress, decimalFactor, getDecimal } from "./helpers";
-import { IUniswapV2Pair, PriceOracle } from "@aurigami/contracts/typechain";
-import { TokenAmount } from "./tokenAmount";
-import { Address, TokenValuation } from "./types";
+import BigNumber from 'bignumber.js';
+import { Contract, providers, BigNumber as BN, ethers } from 'ethers';
+import {
+  DECIMAL_PRECISION,
+  networkAddresses,
+  PRICE_WHITELISTED,
+} from './constants';
+import OracleABI from './abis/Oracle.json';
+import { isSameAddress, decimalFactor, getDecimal } from './helpers';
+import { IUniswapV2Pair, PriceOracle } from '@aurigami/contracts/typechain';
+import { TokenAmount } from './tokenAmount';
+import { Address, TokenValuation } from './types';
 import IUniswapV2PairABI from './abis/IUniswapV2Pair.json';
 import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
 import axios from 'axios';
 import assert from 'assert';
 
 const hardcodePLYPrice = true;
-export async function fetchPriceFromCoingeckoAPI(id: string): Promise<BigNumber> {
-    const price = await axios.get(
+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
-    })
+    )
+    .then((res: any) => {
+      return res.data;
+    });
 
-    return new BigNumber(price[id].usd)
+  return new BigNumber(price[id].usd);
 }
 
 export async function fetchPriceFromCoingecko(id: Address): Promise<BigNumber> {
-    switch (id.toLowerCase()) {
-        case networkAddresses.tokens.AURORA:
-            return fetchPriceFromCoingeckoAPI('aurora-near');
+  switch (id.toLowerCase()) {
+    case networkAddresses.tokens.AURORA:
+      return fetchPriceFromCoingeckoAPI('aurora-near');
 
-        case networkAddresses.tokens.TRI:
-            return fetchPriceFromCoingeckoAPI('trisolaris');
+    case networkAddresses.tokens.TRI:
+      return fetchPriceFromCoingeckoAPI('trisolaris');
 
-        case networkAddresses.tokens.META:
-            return fetchPriceFromCoingeckoAPI('meta-pool');
+    case networkAddresses.tokens.META:
+      return fetchPriceFromCoingeckoAPI('meta-pool');
 
-        default:
-            throw Error(`Unknown token ${id} in fetchPriceFromCoingecko`);
-    }
+    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
+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;
-    var promises: any[] = [];
-    promises.push(LPContract.token0());
-    promises.push(LPContract.token1());
-    promises.push(LPContract.getReserves());
-    promises.push(LPContract.totalSupply());
-    const values: any[] = await Promise.all(promises);
+  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());
+  promises.push(LPContract.totalSupply());
+  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,
-    }
+  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 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));
-    }
+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
+    return await fetchLPPriceBy({
+      address: LPInfo.token0,
+      reserve: LPInfo.reserve0,
+    });
+  } catch {
     try {
-        // MUST await here
-        return await fetchLPPriceBy({address: LPInfo.token0, reserve: LPInfo.reserve0});
+      // MUST await here
+      return await fetchLPPriceBy({
+        address: LPInfo.token1,
+        reserve: LPInfo.reserve1,
+      });
     } catch {
-        try {
-            // MUST await here
-            return await fetchLPPriceBy({address: LPInfo.token1, reserve: LPInfo.reserve1});
-        } catch {
-            throw Error(`Unable to fetch price for both tokens of LP ${address}`);
-        }
+      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));
+  return new BigNumber(rawPrice.toString()).div(
+    decimalFactor(36 - underlyingDecimal)
+  );
 }
-export async function fetchPriceFromOracle(auTokenAddress: Address, underlyingDecimal: number, provider: providers.Provider): Promise<BigNumber> {
-    const oracleContract: PriceOracle = new Contract(networkAddresses.misc.oracle, OracleABI.abi, provider) as PriceOracle;
-    const rawPrice = await oracleContract.getUnderlyingPrice(auTokenAddress);
-    return processPriceFromOracle(rawPrice, underlyingDecimal)
+export async function fetchPriceFromOracle(
+  auTokenAddress: Address,
+  underlyingDecimal: number,
+  provider: providers.Provider
+): Promise<BigNumber> {
+  const oracleContract: PriceOracle = new Contract(
+    networkAddresses.misc.oracle,
+    OracleABI.abi,
+    provider
+  ) as PriceOracle;
+  const rawPrice = await oracleContract.getUnderlyingPrice(auTokenAddress);
+  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])
-        }
-    })
+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]
+      ),
+    };
+  });
 }
 
 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)
+  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 shouldFetchFromCoingecko(address: string) {
-    address = address.toLowerCase();
-    return address == networkAddresses.tokens.AURORA ||
-           address == networkAddresses.tokens.TRI ||
-           address == networkAddresses.tokens.META;
+  address = address.toLowerCase();
+  return (
+    address == networkAddresses.tokens.AURORA ||
+    address == networkAddresses.tokens.TRI ||
+    address == networkAddresses.tokens.META
+  );
 }
 
 /**
  * Fetch price from Oracle or Coingecko
  */
-async function _fetchPrice(address: Address, provider: providers.Provider): Promise<BigNumber> {
-    assert(PRICE_WHITELISTED.has(address.toLocaleLowerCase()));
+async function _fetchPrice(
+  address: Address,
+  provider: providers.Provider
+): Promise<BigNumber> {
+  assert(PRICE_WHITELISTED.has(address.toLocaleLowerCase()));
 
-    if (isSameAddress(address, networkAddresses.tokens.stNEAR)) return fetchStNEARPrice();
-    if (shouldFetchFromCoingecko(address)) return fetchPriceFromCoingecko(address);
+  if (isSameAddress(address, networkAddresses.tokens.stNEAR))
+    return fetchStNEARPrice();
+  if (shouldFetchFromCoingecko(address))
+    return fetchPriceFromCoingecko(address);
 
-    const matchingAuToken = networkAddresses.auTokens.find((auToken) => {
-        return isSameAddress(auToken.underlying, 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}`)
-    }
+  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 (isSameAddress(address, networkAddresses.tokens.PLYUSDC)) {
-        return fetchLPPrice(address, provider)
-    }
-    else if (isSameAddress(address, networkAddresses.tokens.PLY)) {
-        return fetchPLYPrice(provider)
-    }
-    return _fetchPrice(address, provider);
+export async function fetchPrice(
+  address: Address,
+  provider: providers.Provider
+): Promise<BigNumber> {
+  if (isSameAddress(address, networkAddresses.tokens.PLYUSDC)) {
+    return fetchLPPrice(address, provider);
+  } else if (isSameAddress(address, networkAddresses.tokens.PLY)) {
+    return fetchPLYPrice(provider);
+  }
+  return _fetchPrice(address, provider);
 }
 
-export async function fetchPLYPrice(provider: providers.Provider): Promise<BigNumber> {
-    const LPInfo = await fetchLPPositions(networkAddresses.tokens.PLYUSDC, provider);
+export async function fetchPLYPrice(
+  provider: providers.Provider
+): Promise<BigNumber> {
+  const LPInfo = await fetchLPPositions(
+    networkAddresses.tokens.PLYUSDC,
+    provider
+  );
 
-    if (LPInfo.reserve1.isZero()) {
-        return new BigNumber(0);
-    }
+  if (LPInfo.reserve1.isZero()) {
+    return new BigNumber(0);
+  }
 
-    const plyAddress = LPInfo.token0;
-    assert(isSameAddress(plyAddress, networkAddresses.tokens.PLY));
-    const plyDecimal = getDecimal(plyAddress);
-
-    const usdcAddress = LPInfo.token1;
-    assert(isSameAddress(usdcAddress, networkAddresses.tokens.USDC));
-    const usdcDecimal = getDecimal(usdcAddress);
-
-    // (token0Price * reserve0) / 10^decimal0 = (token1Price * reserve1) / 10^decimal1
-    // token0Price = (token1Price * reserve1) * 10^decimal0 / 10^decimal1  / reserve0
-    return (await fetchPrice(usdcAddress, provider))
-        .multipliedBy(LPInfo.reserve1.toString())
-        .multipliedBy(decimalFactor(plyDecimal))
-        .dividedBy(decimalFactor(usdcDecimal))
-        .dividedBy(LPInfo.reserve0.toString());
+  const plyAddress = LPInfo.token0;
+  assert(isSameAddress(plyAddress, networkAddresses.tokens.PLY));
+  const plyDecimal = getDecimal(plyAddress);
+
+  const usdcAddress = LPInfo.token1;
+  assert(isSameAddress(usdcAddress, networkAddresses.tokens.USDC));
+  const usdcDecimal = getDecimal(usdcAddress);
+
+  // (token0Price * reserve0) / 10^decimal0 = (token1Price * reserve1) / 10^decimal1
+  // token0Price = (token1Price * reserve1) * 10^decimal0 / 10^decimal1  / reserve0
+  return (await fetchPrice(usdcAddress, provider))
+    .multipliedBy(LPInfo.reserve1.toString())
+    .multipliedBy(decimalFactor(plyDecimal))
+    .dividedBy(decimalFactor(usdcDecimal))
+    .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 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);
+  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)
-        }
-    }
+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),
+    },
+  };
 }

package/src/token.ts

@@ -1,21 +1,21 @@
-import { getDecimal } from "./helpers";
-import { networkAddresses } from "./constants";
+import { getDecimal } from './helpers';
+import { networkAddresses } from './constants';
 
 export class Token {
-    public readonly address: string;
-    public readonly decimals: number;
-    public constructor(address: string, decimals: number) {
-      this.address = address.toLowerCase();
-      this.decimals = decimals;
-    }
+  public readonly address: string;
+  public readonly decimals: number;
+  public constructor(address: string, decimals: number) {
+    this.address = address.toLowerCase();
+    this.decimals = decimals;
+  }
 }
 
 export const PLYToken = new Token(
-    networkAddresses.tokens.PLY,
-    getDecimal(networkAddresses.tokens.PLY)
-)
+  networkAddresses.tokens.PLY,
+  getDecimal(networkAddresses.tokens.PLY)
+);
 
 export const PLYUSDCToken = new Token(
-    networkAddresses.tokens.PLYUSDC,
-    getDecimal(networkAddresses.tokens.PLYUSDC)
-)
+  networkAddresses.tokens.PLYUSDC,
+  getDecimal(networkAddresses.tokens.PLYUSDC)
+);

package/src/tokenAmount.ts

@@ -1,29 +1,29 @@
-import { Token } from "./token";
+import { Token } from './token';
 import BigNumber from 'bignumber.js';
-import { decimalFactor } from "./helpers";
+import { decimalFactor } from './helpers';
 
 export class TokenAmount {
-    public readonly token: Token;
-    private rawAmnt: string;
+  public readonly token: Token;
+  private rawAmnt: string;
 
-    public constructor(token: Token, amount: string, isRaw: boolean = true) {
-        if (isRaw) {
-            this.rawAmnt = amount;
-        } else {
-            this.rawAmnt = new BigNumber(amount)
-                .times(decimalFactor(token.decimals))
-                .toFixed(0);
-        }
-        this.token = token;
+  public constructor(token: Token, amount: string, isRaw: boolean = true) {
+    if (isRaw) {
+      this.rawAmnt = amount;
+    } else {
+      this.rawAmnt = new BigNumber(amount)
+        .times(decimalFactor(token.decimals))
+        .toFixed(0);
     }
+    this.token = token;
+  }
 
-    public formattedAmount(): string {
-        return new BigNumber(this.rawAmnt)
-            .div(decimalFactor(this.token.decimals))
-            .toString();
-    }
+  public formattedAmount(): string {
+    return new BigNumber(this.rawAmnt)
+      .div(decimalFactor(this.token.decimals))
+      .toString();
+  }
 
-    public rawAmount(): string {
-        return this.rawAmnt;
-    }
+  public rawAmount(): string {
+    return this.rawAmnt;
+  }
 }