@aurigami/sdk 1.6.0-no-src → 1.6.0

package/src/helpers/priceFetcher.ts

@@ -0,0 +1,317 @@
+import BigNumber from 'bignumber.js';
+import { Contract, providers, BigNumber as BN, ethers } from 'ethers';
+import {
+  DECIMAL_PRECISION,
+  networkAddresses,
+  PRICE_WHITELISTED,
+} from '../consts/constants';
+import OracleABI from '../abis/Oracle.json';
+import {
+  isSameAddress,
+  decimalFactor,
+  getDecimal,
+  assert,
+  devLog,
+} from './helpers';
+import { IUniswapV2Pair, PriceOracle } from '@aurigami/contracts/typechain';
+import { TokenAmount } from '../entities/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 (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}`);
+    }
+  }
+}
+
+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/helpers/transfer-event-query.ts

@@ -0,0 +1,70 @@
+import { BlockchainEntityRead } from '../entities/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/index.ts

@@ -0,0 +1,13 @@
+import BigNumber from 'bignumber.js';
+import { ethers } from 'ethers';
+import { Logger } from 'ethers/lib/utils';
+
+ethers.utils.Logger.setLogLevel(Logger.levels.ERROR);
+BigNumber.config({ DECIMAL_PLACES: 50 });
+
+export * from './consts';
+export * from './contracts';
+export * from './entities';
+export * from './helpers';
+export * from './types';
+export * from './SDK';

package/src/misc/airdrop_misc/auTokensInfo.json

@@ -0,0 +1,34 @@
+{
+    "auUSDC": {
+        "address": "0x4f0d864b1ABf4B701799a0b30b57A22dFEB5917b",
+        "exchangeRate": "200810680770707",
+        "deploymentBlock": "60501576",
+        "underlying": {
+            "minDeposit": "1000000000"
+        }
+    },
+    "auETH": {
+        "address": "0xca9511B610bA5fc7E311FDeF9cE16050eE4449E9",
+        "exchangeRate": "200390813218617347858934298",
+        "deploymentBlock": "60501625",
+        "underlying": {
+            "minDeposit": "300000000000000000"
+        }
+    },
+    "auWBTC": {
+        "address": "0xCFb6b0498cb7555e7e21502E0F449bf28760Adbb",
+        "exchangeRate": "20050472926613996",
+        "deploymentBlock": "60501670",
+        "underlying": {
+            "minDeposit": "2000000"
+        }
+    },
+    "auUSDT": {
+        "address": "0xaD5A2437Ff55ed7A8Cad3b797b3eC7c5a19B1c54",
+        "exchangeRate": "200868369820223",
+        "deploymentBlock": "60501723",
+        "underlying": {
+            "minDeposit": "1000000000"
+        }
+    }
+}