@aurigami/sdk 1.24.0 → 1.24.1

package/src/helpers/priceFetcher.ts

@@ -1,388 +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, 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 { createContract } from './multicall';
-import { getQuoteOneInch } from './one-inch-aggregator-api';
-
-export async function prepareParamsAggregator(address: string, provider: providers.Provider) {
-  const tokenInErc20 = createContract<ERC20>(address, EIP20InterfaceABI.abi, provider);
-  const tokenInDecimal = await tokenInErc20.callStatic.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 = createContract<IUniswapV2Pair>(LPAddress, IUniswapV2PairABI.abi, provider);
-  const [token0, token1, reserves, totalSupply] = await Promise.all([
-    LPContract.callStatic.token0(),
-    LPContract.callStatic.token1(),
-    LPContract.callStatic.getReserves(),
-    LPContract.callStatic.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 = createContract<AuriPythOracle>(
-    networkAddresses.misc.PYTH_ORACLE,
-    AuriOracleABI.abi,
-    provider
-  );
-  const rawPrice = await oracleContract.callStatic
-    .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 = createContract(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.callStatic.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),
-    },
-  };
-}

package/src/helpers/subgraphQuery.ts

@@ -1,17 +0,0 @@
-export function getLiquidationEventsQuery(address: string, limit: number) {
-  return `{
-    liquidationEvents(
-      first: ${limit},
-      where: {from: "${address.toLowerCase()}"}
-    ) {
-      amount
-      auTokenSymbol
-      blockTime
-      from
-      id
-      underlyingRepayAmountUSD
-      underlyingSymbol
-      underlyingRepayAmount
-    }
-  }`;
-}

package/src/helpers/transfer-event-query.ts

@@ -1,68 +0,0 @@
-import AuTokenABI from '@aurigami/contracts/artifacts/contracts/AuToken.sol/AuToken.json';
-import { AuToken } from '@aurigami/contracts/typechain';
-import { BigNumber as BN, Contract } from 'ethers';
-import { BlockchainEntityRead } from '../entities/BlockchainEntity';
-import { NetworkConnection } from '../types';
-
-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

@@ -1,14 +0,0 @@
-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 * as abis from './abis';
-export * from './consts';
-export * from './entities';
-export * from './helpers';
-export * from './interactors';
-export * from './SDK';
-export * from './types';

package/src/interactors/Airdrop.ts

@@ -1,72 +0,0 @@
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { BigNumber as BN, utils } from 'ethers';
-import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from '../entities';
-import * as helpers from '../helpers';
-import { Address, NetworkConnection } from '../types';
-
-export class AirdropRead extends BlockchainEntityRead {
-  public readonly env: AuriEnv;
-
-  public constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-  }
-
-  /**
-   * Get redeemable rewards amount of user
-   */
-  public async getRedeemableReward(
-    campaign: string,
-    token: Address,
-    user: Address
-  ): Promise<TokenAmount> {
-    let tokenInstance: Token = new Token(token, helpers.getDecimal(token));
-
-    let rewards: BN = await this.env.auriAirdrop.raw.getRedeemableReward(
-      utils.formatBytes32String(campaign),
-      token,
-      user
-    );
-
-    return new TokenAmount(tokenInstance, rewards.toString());
-  }
-}
-
-export class AirdropReadWrite extends AirdropRead {
-  /**
-   * Transfer rewards from multiple campaigns to msg.sender
-   */
-  public async redeemMultiple(
-    campaigns: string[],
-    tokens: Address[]
-  ): Promise<TransactionResponse> {
-    helpers.assert(
-      campaigns.length == tokens.length,
-      'campaigns and tokens must have the same length'
-    );
-    return this.env.auriAirdrop.raw.connect(this._networkConnection.signer!).redeem(
-      campaigns.map((e) => utils.formatBytes32String(e)),
-      tokens,
-      await this._networkConnection.signer!.getAddress()
-    );
-  }
-
-  /**
-   * Redeem reward from a single campaign
-   */
-  public async redeemSingle(campaign: string, token: Address): Promise<TransactionResponse> {
-    return this.redeemMultiple([campaign], [token]);
-  }
-}
-
-export class Airdrop extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): AirdropRead {
-    return new AirdropRead(networkConnection);
-  }
-  public readWrite(networkConnection: NetworkConnection): AirdropReadWrite {
-    return new AirdropReadWrite(networkConnection);
-  }
-}