@aurigami/sdk 1.4.7 → 1.5.0-dummy

package/src/helpers.ts

@@ -6,6 +6,7 @@ import { BigNumber as BN, Contract, providers, utils } from "ethers";
 import { getQuery as getAuroraAPIQuery } from "./aurora-api-helpers";
 import { decimalRecords } from "./decimals";
 import { Address, NetworkConnection } from "./types";
+import assert from 'assert';
 
 export function formatObject(object: Object) {
   return JSON.stringify(object, null, '  ');
@@ -32,7 +33,9 @@ export function validateAndParseAddress(address: Address): Address {
 }
 
 export function getDecimal(address: Address): number {
-  return decimalRecords[address.toLowerCase()];
+  let addressLowercase = address.toLowerCase();
+  assert(decimalRecords[addressLowercase] != undefined, "Decimal not found for " + address);
+  return decimalRecords[addressLowercase];
 }
 
 export function calcLMRewardApr(rewardsValue: BigNumber, totalStakeValue: BigNumber, frequencyPerYear: number): BigNumber {

package/src/index.ts

@@ -17,3 +17,4 @@ export * from './tokenAmount';
 export * from './types';
 export * from './airdrop-lottery';
 export * from './transfer-event-query';
+export * from './Papermill';

package/src/priceFetcher.ts

@@ -1,14 +1,15 @@
 import BigNumber from "bignumber.js";
 import { Contract, providers, BigNumber as BN, ethers } from "ethers";
-import { networkAddresses } from "./constants";
+import { DECIMAL_PRECISION, networkAddresses, PRICE_WHITELISTED } from "./constants";
 import OracleABI from "./abis/Oracle.json";
 import { isSameAddress, decimalFactor, getDecimal } from "./helpers";
-import { PriceOracle } from "@aurigami/contracts/typechain";
+import { IUniswapV2Pair, PriceOracle } from "@aurigami/contracts/typechain";
 import { TokenAmount } from "./tokenAmount";
-import { Address } from "./types";
+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> {
@@ -44,38 +45,56 @@ export async function fetchLPPositions(LPAddress: Address, provider: providers.P
     reserve1: BN,
     totalSupply: BN
 }> {
-    var promises = [];
-    const LPContract = new Contract(LPAddress, IUniswapV2PairABI.abi, provider);
+    const LPContract = new Contract(LPAddress, IUniswapV2PairABI.abi, provider) as IUniswapV2Pair;
+    var promises: any[] = [];
     promises.push(LPContract.token0());
-    promises.push(LPContract.toekn1());
+    promises.push(LPContract.token1());
     promises.push(LPContract.getReserves());
     promises.push(LPContract.totalSupply());
-    const values = await Promise.all(promises);
+    const values: any[] = await Promise.all(promises);
+
     return {
-        token0: values[0],
-        token1: values[1],
-        reserve0: values[2].reserve0,
-        reserve1: values[2].reserve1,
-        totalSupply: values[3]
+        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 {
-      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.token0, reserve: LPInfo.reserve0});
     } 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}`);
-      }
+        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));
@@ -117,8 +136,11 @@ function shouldFetchFromCoingecko(address: string) {
            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);
@@ -126,14 +148,48 @@ export async function fetchPrice(address: Address, provider: providers.Provider)
     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);
+        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);
@@ -143,3 +199,14 @@ export async function fetchValuation(tokenAmount: TokenAmount, provider: provide
 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

@@ -3,19 +3,19 @@ import { networkAddresses } from "./constants";
 
 export class Token {
     public readonly address: string;
-    public readonly decimals: number;  
+    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)
-)
+
+export const PLYUSDCToken = new Token(
+    networkAddresses.tokens.PLYUSDC,
+    getDecimal(networkAddresses.tokens.PLYUSDC)
+)

package/src/types.ts

@@ -17,6 +17,11 @@ export type CurrencyAmount = {
   amount: string
 };
 
+export type TokenValuation = {
+  tokenAmount: TokenAmount,
+  currencyAmount: CurrencyAmount,
+}
+
 export type MoneyMarketDetails = {
   auTokenAddress: string;
   totalTokenDeposited: TokenAmount;
@@ -36,20 +41,34 @@ export type MoneyMarketDetails = {
 export type UserDetails = {
   markets: UserMarketDetails[];
   borrowLimit: CurrencyAmount;
-  accruedPly: TokenAmount;
-  lockedPly: TokenAmount;
+  userLockingDetails: UserLockingDetails;
   borrowableAmount: CurrencyAmount;
 };
 
-export type LockingDetails = {
+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;
-};
-
-export type PlyAuroraPool = {
-  totalStakedLiquidity: CurrencyAmount;
-  apy: 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 = {
@@ -62,8 +81,8 @@ export type UserMarketDetails = {
   underlyingPrice: string;
 };
 
-export type PlyAuroraPoolDetails = {
-  totalStakedLiquidity: TokenAmount;
+export type PlyUsdcPoolDetails = {
+  totalStakedLiquidity: TokenValuation;
   apy: string;
 };
 
@@ -75,7 +94,8 @@ export enum MarketAction {
   EnableCollateral,
   DisableCollateral
 }
+
 export type HypotheticalStats = {
   newBorrowLimit: CurrencyAmount;
   newBorrowUtilization: number;
-}
+}