@aurigami/sdk 1.5.10 → 1.6.0-no-src

package/src/priceFetcher.ts

@@ -1,309 +0,0 @@
-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, assert } 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';
-
-const hardcodePLYPrice = true;
-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;
-    });
-
-  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');
-
-    case networkAddresses.tokens.TRI:
-      return fetchPriceFromCoingeckoAPI('trisolaris');
-
-    case networkAddresses.tokens.META:
-      return fetchPriceFromCoingeckoAPI('meta-pool');
-
-    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;
-  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);
-  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.token1,
-        reserve: LPInfo.reserve1,
-      });
-    } catch {
-      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 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 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 shouldFetchFromCoingecko(address: string) {
-  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()),
-    `Address ${address} is not whitelisted for price fetching`
-  );
-
-  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 {
-    throw Error(`Unable to fetch price for ${address}`);
-  }
-}
-
-export async function fetchPrice(
-  address: Address,
-  provider: providers.Provider
-): Promise<BigNumber> {
-  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),
-    },
-  };
-}

package/src/token.ts

@@ -1,21 +0,0 @@
-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;
-  }
-}
-
-export const PLYToken = new Token(
-  networkAddresses.tokens.PLY,
-  getDecimal(networkAddresses.tokens.PLY)
-);
-
-export const PLYWNEARToken = new Token(
-  networkAddresses.tokens.PLYWNEAR,
-  getDecimal(networkAddresses.tokens.PLYWNEAR)
-);

package/src/tokenAmount.ts

@@ -1,42 +0,0 @@
-import { Token } from './token';
-import BigNumber from 'bignumber.js';
-import { decimalFactor, getDecimal } from './helpers';
-import { Address } from './types';
-
-export class TokenAmount {
-  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 formattedAmount(): string {
-    return new BigNumber(this.rawAmnt)
-      .div(decimalFactor(this.token.decimals))
-      .toString();
-  }
-
-  public rawAmount(): string {
-    return this.rawAmnt;
-  }
-
-  public static fromAddressAndAmount(
-    tokenAddress: Address,
-    amount: string,
-    isRaw: boolean = true
-  ): TokenAmount {
-    return new TokenAmount(
-      new Token(tokenAddress, getDecimal(tokenAddress)),
-      amount,
-      isRaw
-    );
-  }
-}

package/src/transfer-event-query.ts

@@ -1,70 +0,0 @@
-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';
-
-type SimpleTransfer = {
-  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 });
-  }
-}

package/src/types.ts

@@ -1,106 +0,0 @@
-import type { BigNumber, providers, Signer } from 'ethers';
-import { TokenAmount } from './tokenAmount';
-
-export enum ComptrollerRewardType {
-  PLY = 0,
-  AURORA,
-}
-export type NetworkConnection = {
-  provider: providers.Provider;
-  signer?: Signer;
-};
-
-export type Address = string;
-
-export type CurrencyAmount = {
-  currency: string;
-  amount: string;
-};
-
-export type TokenValuation = {
-  tokenAmount: TokenAmount;
-  currencyAmount: CurrencyAmount;
-};
-
-export type MoneyMarketDetails = {
-  auTokenAddress: string;
-  totalTokenDeposited: TokenAmount;
-  totalTokenBorrowed: TokenAmount;
-  depositApy: number;
-  depositPlyApy: number;
-  borrowApy: number;
-  borrowPlyApy: number;
-  collateralRatio: number;
-  depositPlyPerWeek: TokenAmount;
-  borrowPlyPerWeek: TokenAmount;
-  depositMETAApy: number;
-  depositNEARApy: number;
-  borrowNEARApy: number;
-};
-
-export type UserDetails = {
-  markets: UserMarketDetails[];
-  borrowLimit: CurrencyAmount;
-  userLockingDetails: UserLockingDetails;
-  borrowableAmount: CurrencyAmount;
-};
-
-export type UserLockingDetails = {
-  vestingStart: number;
-  /** % of reward they will receive in PLY, if they claim this week */
-  currentUnlockPortion: number;
-  //** Amount of PLY rewards that a user has. Equal to currentPly + currentPulp */
-  accruedPly: TokenAmount;
-  /** Amount of PLY they will receive, if they claim this week */
-  currentPly: TokenAmount;
-  /** Amount of PULP they will receive, if they claim this week */
-  currentPulp: TokenAmount;
-  /** % of reward they will receive in PLY, if they claim next week */
-  nextUnlockPortion: number;
-  /**
-   * Amount of PLY they will receive, if they claim next week.
-   * This doesn't include the additional reward that they will earn
-   * in the next week.
-   */
-  nextPly: TokenAmount;
-  /**
-   * Amount of PULP they will receive, if they claim next week.
-   * This doesn't include the additional reward that they will earn
-   * in the next week.
-   */
-  nextPulp: TokenAmount;
-};
-
-export type UserMarketDetails = {
-  market: string;
-  depositBalance: TokenAmount;
-  borrowBalance: TokenAmount;
-  isCollateral: boolean;
-  maxWithdrawableAmount: TokenAmount;
-  collateralRatio: number;
-  underlyingPrice: string;
-};
-
-export type TokenAPY = {
-  address: string;
-  apy: string;
-};
-
-export type PLYWNEARPoolDetails = {
-  totalStakedLiquidity: TokenAmount;
-  APYs: TokenAPY[];
-};
-
-export enum MarketAction {
-  Deposit = 0,
-  Borrow,
-  Withdraw,
-  Repay,
-  EnableCollateral,
-  DisableCollateral,
-}
-
-export type HypotheticalStats = {
-  newBorrowLimit: CurrencyAmount;
-  newBorrowUtilization: number;
-};