@aurigami/sdk 1.12.7 → 1.12.9-hf

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "1.12.7",
+    "version": "1.12.9-hf",
     "license": "MIT",
     "main": "dist/index.js",
     "typings": "dist/index.d.ts",
@@ -70,4 +70,4 @@
     "jest": {
         "testURL": "https://app.aurigami.finance"
     }
-}
+}

package/src/consts/constants.ts

@@ -106,6 +106,9 @@ export const networkAddresses: NetworkAddresses = {
     PULP: MAINNET_ADDRESSES.PULP.toLowerCase(),
     PLYWNEAR: MAINNET_ADDRESSES.ply_wnear_lp.toLowerCase(),
     USN: '0x5183e1b1091804bc2602586919e6880ac1cf2896'.toLowerCase(),
+    PLY_WNEAR: '0x044b6b0cd3bb13d2b9057781df4459c66781dce7'.toLowerCase(),
+    WNEAR_TRI: '0x84b123875f0f36b966d0b6ca14b31121bd9676ad'.toLowerCase(),
+    AURORA_WNEAR: '0x1e0e812fbcd3eb75d8562ad6f310ed94d258d008'.toLowerCase(),
   },
 };
 

package/src/consts/decimals.ts

@@ -22,4 +22,6 @@ export const decimalRecords: Record<string, number> = {
   '0x04ac48711bcdc45b4d223fb021e09da73c71095e': 18, // PULP
   '0x044b6b0cd3bb13d2b9057781df4459c66781dce7': 18, // PLYWNEAR
   '0x5183e1b1091804bc2602586919e6880ac1cf2896': 18, // USN
+  '0x84b123875f0f36b966d0b6ca14b31121bd9676ad': 18, //WNEAR_TRI,
+  '0x1e0e812fbcd3eb75d8562ad6f310ed94d258d008': 18, //AURORA_WNEAR
 };

package/src/helpers/historicalPriceFetcher.ts

@@ -0,0 +1,196 @@
+import { IUniswapV2Pair, PriceOracle } from '@aurigami/contracts/typechain';
+import BigNumber from 'bignumber.js';
+import { BigNumber as BN, Contract, providers } from 'ethers';
+import { AuriOracleABI, IUniswapV2PairABI } from '../abis';
+import { HARDCODE_PRICE_TOKENS, networkAddresses } from '../consts/constants';
+import { Address } from '../types';
+import { decimalFactor, devLog, getDecimal, isSameAddress } from './helpers';
+
+export async function fetchHistoricalLPPositions(
+  LPAddress: Address,
+  provider: providers.Provider,
+  block: number
+): 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({ blockTag: block }));
+  promises.push(LPContract.totalSupply({ blockTag: block }));
+  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 fetchHistoricalLPPrice(
+  address: Address,
+  provider: providers.Provider,
+  block: number
+): Promise<BigNumber> {
+  var LPInfo = await fetchHistoricalLPPositions(address, provider, block);
+  const LPDecimal = getDecimal(address);
+
+  async function fetchLPPriceBy(
+    tokenReverse: {
+      address: string;
+      reserve: BN;
+    },
+    block: number
+  ): Promise<BigNumber> {
+    if (tokenReverse.reserve.isZero()) return new BigNumber(0);
+
+    const tokenPrice: BigNumber = await fetchHistoricalPrice(tokenReverse.address, provider, block);
+    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,
+      },
+      block
+    );
+    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,
+        },
+        block
+      );
+    } 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 fetchHistoricalPriceFromOracle(
+  auTokenAddress: Address,
+  underlyingDecimal: number,
+  provider: providers.Provider,
+  block: number
+): Promise<BigNumber> {
+  const oracleContract: PriceOracle = new Contract(
+    networkAddresses.misc.oracle,
+    AuriOracleABI.abi,
+    provider
+  ) as PriceOracle;
+  const rawPrice = await oracleContract
+    .getUnderlyingPrice(auTokenAddress, { blockTag: block })
+    .catch((e: any) => {
+      console.log(`Unable to fetch price from oracle for ${auTokenAddress}`);
+      return BN.from(0);
+    });
+
+  return processPriceFromOracle(rawPrice, underlyingDecimal);
+}
+
+export async function fetchHistoricalPrice(
+  address: Address,
+  provider: providers.Provider,
+  block: number
+): Promise<BigNumber> {
+  if (address.toLowerCase() in HARDCODE_PRICE_TOKENS) {
+    return new BigNumber(HARDCODE_PRICE_TOKENS[address.toLowerCase()]);
+  } else if (
+    isSameAddress(address, networkAddresses.tokens.PLY_WNEAR) ||
+    isSameAddress(address, networkAddresses.tokens.WNEAR_TRI) ||
+    isSameAddress(address, networkAddresses.tokens.AURORA_WNEAR)
+  ) {
+    return fetchHistoricalLPPrice(address, provider, block);
+  } else if (isSameAddress(address, networkAddresses.tokens.PLY)) {
+    return fetchHistoricalPriceByLP(networkAddresses.tokens.PLY_WNEAR, provider, block);
+  } else if (isSameAddress(address, networkAddresses.tokens.TRI)) {
+    return fetchHistoricalPriceByLP(networkAddresses.tokens.WNEAR_TRI, provider, block, 1);
+  } else if (isSameAddress(address, networkAddresses.tokens.AURORA)) {
+    return fetchHistoricalPriceByLP(networkAddresses.tokens.AURORA_WNEAR, provider, block);
+  }
+
+  const matchingAuToken = networkAddresses.auTokens.find((auToken) => {
+    return isSameAddress(auToken.underlying, address);
+  });
+
+  if (matchingAuToken !== undefined) {
+    return fetchHistoricalPriceFromOracle(
+      matchingAuToken.address,
+      getDecimal(address),
+      provider,
+      block
+    );
+  } else {
+    throw Error(`Unable to fetch price for ${address}`);
+  }
+}
+
+export async function fetchHistoricalPULPPrice(provider: providers.Provider): Promise<BigNumber> {
+  //TODO: Calculate PULP price
+  return new BigNumber(0);
+}
+
+export async function fetchHistoricalPriceByLP(
+  LP: Address,
+  provider: providers.Provider,
+  block: number,
+  tokenNumber: 0 | 1 = 0
+): Promise<BigNumber> {
+  let LPInfo = await fetchHistoricalLPPositions(LP, provider, block);
+
+  if (tokenNumber === 1) {
+    LPInfo = {
+      token0: LPInfo.token1,
+      token1: LPInfo.token0,
+      reserve0: LPInfo.reserve1,
+      reserve1: LPInfo.reserve0,
+      totalSupply: LPInfo.totalSupply,
+    };
+  }
+
+  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 fetchHistoricalPrice(LPInfo.token1, provider, block))
+    .multipliedBy(LPInfo.reserve1.toString())
+    .multipliedBy(decimalFactor(token0Decimal))
+    .dividedBy(decimalFactor(token1Decimal))
+    .dividedBy(LPInfo.reserve0.toString());
+}

package/src/helpers/index.ts

@@ -4,3 +4,4 @@ export * from './graphql-helpers';
 export * from './helpers';
 export * from './priceFetcher';
 export * from './transfer-event-query';
+export * from './historicalPriceFetcher';

package/src/interactors/MoneyMarket.ts

@@ -332,6 +332,18 @@ export class MoneyMarketRead extends BlockchainEntityRead {
       return new TokenAmount(NEARToken, '0');
     }
   }
+  public async mintCap(): Promise<TokenAmount> {
+    return new TokenAmount(
+      this.underlying,
+      (await this.env.comptroller.mintCaps(this.auToken.address)).toString()
+    );
+  }
+  public async borrowCap(): Promise<TokenAmount> {
+    return new TokenAmount(
+      this.underlying,
+      (await this.env.comptroller.borrowCaps(this.auToken.address)).toString()
+    );
+  }
 }
 
 export class MoneyMarketReadWrite extends MoneyMarketRead {

package/src/interactors/PlyGame.ts

@@ -10,7 +10,7 @@ import {
   NetworkConnection,
   PlyBetMadeEvent,
   PlyGameBetResult,
-  PlyGameLeaderboardItem,
+  PlyGameLeaderboardItem
 } from '../types';
 
 export class PlyGameRead extends BlockchainEntityRead {
@@ -131,6 +131,15 @@ export class PlyGameRead extends BlockchainEntityRead {
       amount: new TokenAmount(this.plyToken, result.amount.toString()),
     };
   }
+
+  public async overallLeaderboard(): Promise<PlyGameLeaderboardItem[]> {
+    const result = await AuriAPI.getPaginatedApi('/plygame/overallLeaderboard');
+    return result.items.map((item) => ({
+      player: item.user,
+      unlockedPulpAmount: new TokenAmount(this.pulpToken, item.unlockedAmount!),
+      gamesPlayed: item.count!,
+    }));
+  }
 }
 
 export class PlyGameReadWrite extends PlyGameRead {

package/src/interactors/misc.ts

@@ -88,7 +88,10 @@ export class MiscRead extends BlockchainEntityRead {
       return p;
     }, new BigNumber(0));
 
-    var accountLiquidity: [BN, BN] = await this.env.comptroller.getAccountLiquidity(userAddress);
+    var accountLiquidity: [BN, BN] = await this.env.comptroller.getAccountLiquidity(userAddress).catch((e) => {
+      console.log(e);
+      return [BN.from(0), BN.from(0)]
+    });
 
     var borrowedvaluation: BigNumber = totalBorrowLimit.minus(
       new BigNumber(accountLiquidity[0].toString()).div(decimalFactor(18))
@@ -126,12 +129,12 @@ export class MiscRead extends BlockchainEntityRead {
         .div(underlyingPrices[i]);
       userMarketDetails[i].maxWithdrawableAmount =
         userMarketDetails[i].isCollateral &&
-        maxWithdrawCap.lt(userMarketDetails[i].depositBalance.formattedAmount())
+          maxWithdrawCap.lt(userMarketDetails[i].depositBalance.formattedAmount())
           ? new TokenAmount(moneyMarket.underlying, maxWithdrawCap.toFixed(24), false)
           : new TokenAmount(
-              moneyMarket.underlying,
-              userMarketDetails[i].depositBalance.rawAmount()
-            );
+            moneyMarket.underlying,
+            userMarketDetails[i].depositBalance.rawAmount()
+          );
     }
 
     return {