@aurigami/sdk 1.4.8 → 1.5.0-dummy-1

package/src/priceFetcher.ts

@@ -1,145 +1,298 @@
-import BigNumber from "bignumber.js";
-import { Contract, providers, BigNumber as BN, ethers } from "ethers";
-import { networkAddresses } from "./constants";
-import OracleABI from "./abis/Oracle.json";
-import { isSameAddress, decimalFactor, getDecimal } from "./helpers";
-import { PriceOracle } from "@aurigami/contracts/typechain";
-import { TokenAmount } from "./tokenAmount";
-import { Address } 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;
 }> {
-    var promises = [];
-    const LPContract = new Contract(LPAddress, IUniswapV2PairABI.abi, provider);
-    promises.push(LPContract.token0());
-    promises.push(LPContract.toekn1());
-    promises.push(LPContract.getReserves());
-    promises.push(LPContract.totalSupply());
-    const values = await Promise.all(promises);
-    return {
-        token0: values[0],
-        token1: values[1],
-        reserve0: values[2].reserve0,
-        reserve1: values[2].reserve1,
-        totalSupply: values[3]
-    }
+  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,
+  };
 }
 
-export async function fetchLPPrice(address: Address, provider: providers.Provider): Promise<BigNumber> {
-    var LPInfo = await fetchLPPositions(address, provider);
+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 {
-      const token0Price: BigNumber = await fetchPrice(LPInfo.token0, provider);
-      const reserveUSD: BigNumber = token0Price.multipliedBy(LPInfo.reserve0.toString()).multipliedBy(2);
-      return reserveUSD.multipliedBy(decimalFactor(18)).dividedBy(new BigNumber(LPInfo.totalSupply.toString()));
+      // MUST await here
+      return await fetchLPPriceBy({
+        address: LPInfo.token1,
+        reserve: LPInfo.reserve1,
+      });
     } catch {
-      try {
-        const token1Price: BigNumber = await fetchPrice(LPInfo.token1, provider);
-        const reserveUSD: BigNumber = token1Price.multipliedBy(LPInfo.reserve1.toString()).multipliedBy(2);
-        return reserveUSD.multipliedBy(decimalFactor(18)).dividedBy(new BigNumber(LPInfo.totalSupply.toString()));
-    } 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
+  );
 }
 
-export async function fetchPrice(address: Address, provider: providers.Provider): Promise<BigNumber> {
-    if (hardcodePLYPrice && isSameAddress(address, networkAddresses.tokens.PLY)) return new BigNumber(0);
+/**
+ * Fetch price from Oracle or Coingecko
+ */
+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)
-    });
-    if (matchingAuToken !== undefined) {
-        return fetchPriceFromOracle(matchingAuToken.address, getDecimal(address), provider);
-    } else if (isSameAddress(address, networkAddresses.tokens.AURPLY)) {
-        return fetchLPPrice(address, provider);
-    } else {
-        return fetchPriceFromCoingecko(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 (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
+  );
+
+  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());
 }
-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),
+    },
+  };
 }

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)
-)
-    
-export const AURPLYToken = new Token(
-    networkAddresses.tokens.AURPLY,
-    getDecimal(networkAddresses.tokens.AURPLY)
-)
+  networkAddresses.tokens.PLY,
+  getDecimal(networkAddresses.tokens.PLY)
+);
+
+export const PLYUSDCToken = new Token(
+  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;
+  }
 }

package/src/transfer-event-query.ts

@@ -1,60 +1,70 @@
-import { BlockchainEntityRead } from "./BlockchainEntity";
-import { NetworkConnection } from "./types";
-import { AuToken } from "@aurigami/contracts/typechain";
+import { BlockchainEntityRead } from './BlockchainEntity';
+import { NetworkConnection } from './types';
+import { AuToken } from '@aurigami/contracts/typechain';
 import AuTokenABI from '@aurigami/contracts/artifacts/contracts/AuToken.sol/AuToken.json';
-import { BigNumber as BN, Contract } from "ethers";
+import { BigNumber as BN, Contract } from 'ethers';
 
 type SimpleTransfer = {
-    from: string;
-    to: string;
-    amount: BN;
-    blockNumber: number;
-}
-
+  from: string;
+  to: string;
+  amount: BN;
+  blockNumber: number;
+};
 
 export class TransferEventQuery extends BlockchainEntityRead {
-    auToken: AuToken;
-
-    constructor(
-        tokenAddr: string,
-        networkConnection: NetworkConnection
-    ) {
-        super(networkConnection);
-        this.auToken = new Contract(tokenAddr, AuTokenABI.abi, this._networkConnection.provider) as AuToken;
-    }
-
-    /**
-     * query ERC20 transfers from/to an address & auto convert them into SimpleTransfer.
-     * The result will be sorted by blocknumber.
-     */
-    async queryERC20TransfersOf(address: string, fromBlock: number, toBlock: number): Promise<SimpleTransfer[]> {
-        const filters = [
-            this.auToken.filters.Transfer(address, null),
-            this.auToken.filters.Transfer(null, address)
-        ]
-
-        const events = (await Promise.all(filters.map(filter => this.auToken.queryFilter(filter, fromBlock, toBlock)))).flat();
-
-        let results: SimpleTransfer[] = events.map((event) => {
-            return {
-                from: event.args![0],
-                to: event.args![1],
-                amount: event.args![2],
-                blockNumber: event.blockNumber,
-            };
-        });
-
-        results.sort((a, b) => a.blockNumber - b.blockNumber);
-
-        return results;
-    }
-
-    /**
-     * Get the balance of an address at a given block number.
-     *
-     * Note that this will return the balance after the block get mined.
-     */
-    async queryERC20BalanceAt(address: string, endBlock: number): Promise<BN> {
-        return this.auToken.balanceOf(address, {blockTag: endBlock + 1});
-    }
+  auToken: AuToken;
+
+  constructor(tokenAddr: string, networkConnection: NetworkConnection) {
+    super(networkConnection);
+    this.auToken = new Contract(
+      tokenAddr,
+      AuTokenABI.abi,
+      this._networkConnection.provider
+    ) as AuToken;
+  }
+
+  /**
+   * query ERC20 transfers from/to an address & auto convert them into SimpleTransfer.
+   * The result will be sorted by blocknumber.
+   */
+  async queryERC20TransfersOf(
+    address: string,
+    fromBlock: number,
+    toBlock: number
+  ): Promise<SimpleTransfer[]> {
+    const filters = [
+      this.auToken.filters.Transfer(address, null),
+      this.auToken.filters.Transfer(null, address),
+    ];
+
+    const events = (
+      await Promise.all(
+        filters.map((filter) =>
+          this.auToken.queryFilter(filter, fromBlock, toBlock)
+        )
+      )
+    ).flat();
+
+    let results: SimpleTransfer[] = events.map((event) => {
+      return {
+        from: event.args![0],
+        to: event.args![1],
+        amount: event.args![2],
+        blockNumber: event.blockNumber,
+      };
+    });
+
+    results.sort((a, b) => a.blockNumber - b.blockNumber);
+
+    return results;
+  }
+
+  /**
+   * Get the balance of an address at a given block number.
+   *
+   * Note that this will return the balance after the block get mined.
+   */
+  async queryERC20BalanceAt(address: string, endBlock: number): Promise<BN> {
+    return this.auToken.balanceOf(address, { blockTag: endBlock + 1 });
+  }
 }