@aurigami/sdk 0.2.1 → 0.2.5

package/src/MoneyMarket.ts

@@ -1,6 +1,5 @@
 import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
-import { MoneyMarketDetails, NetworkConnection, Address } from './types';
-
+import { MoneyMarketDetails, NetworkConnection, Address, ComptrollerRewardType } from './types';
 import { Contract, BigNumber as BN } from 'ethers';
 import AuErc20ABI from '@aurigami/contracts/artifacts/contracts/AuErc20.sol/AuErc20.json';
 import AuETHABI from '@aurigami/contracts/artifacts/contracts/AuETH.sol/AuETH.json';
@@ -13,6 +12,7 @@ import { decimalFactor, isSameAddress } from './helpers';
 import { Token } from './token';
 import { TokenAmount } from './tokenAmount';
 import { getDecimal, validateAndParseAddress } from './helpers';
+import { calcLMRewardApr, DECIMAL_PRECISION, fetchPrice, fetchPriceFromCoingecko, ONE_YEAR, PLYToken } from '.';
 
 export class MoneyMarketRead extends BlockchainEntityRead {
   public underlying: Token;
@@ -70,6 +70,40 @@ export class MoneyMarketRead extends BlockchainEntityRead {
       return new BigNumber(res.collateralFactorMantissa.toString()).div(decimalFactor(18));
     })
   }
+
+  public async getBorrowPlyAPY(): Promise<BigNumber> {
+    var promises = [];
+    var totalBorrowed: TokenAmount, rewardSpeed: TokenAmount, plyPrice: BigNumber, underlyingPrice: BigNumber;
+    promises.push(this.getTotalTokenBorrowed().then((res: TokenAmount) => {totalBorrowed = res}));
+    promises.push(this._comptroller.rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address).then((res) => {
+      rewardSpeed = new TokenAmount(
+        PLYToken,
+        res.toString()
+      )
+    }));
+    promises.push(fetchPrice(networkAddresses.tokens.PLY, this._networkConnection.provider).then((res) => {plyPrice = res}));
+    promises.push(fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {underlyingPrice = res}));
+    await Promise.all(promises);
+    return calcLMRewardApr(plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+    underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()), ONE_YEAR);
+  }
+
+  public async getDepositPlyAPY(): Promise<BigNumber> {
+    var promises = [];
+    var totalDeposited: TokenAmount, rewardSpeed: TokenAmount, plyPrice: BigNumber, underlyingPrice: BigNumber;
+    promises.push(this.getTotalTokenDeposited().then((res: TokenAmount) => {totalDeposited = res}));
+    promises.push(this._comptroller.rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address).then((res) => {
+      rewardSpeed = new TokenAmount(
+        PLYToken,
+        res.toString()
+      )
+    }));
+    promises.push(fetchPrice(networkAddresses.tokens.PLY, this._networkConnection.provider).then((res) => {plyPrice = res}));
+    promises.push(fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {underlyingPrice = res}));
+    await Promise.all(promises);
+    return calcLMRewardApr(plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+    underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()), ONE_YEAR);
+  }
   public async getDetails(): Promise<MoneyMarketDetails> {
     var promises = [], totalDeposited: TokenAmount, totalBorrowed: TokenAmount, depositAPY: number, borrowAPY: number, collateralRatio: number;
     promises.push(this.getTotalTokenDeposited().then((res: TokenAmount) => {totalDeposited = res}));
@@ -77,16 +111,32 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     promises.push(this.getDepositAPY().then((res: BigNumber) => {depositAPY = res.toNumber()}));
     promises.push(this.getBorrowAPY().then((res: BigNumber) => {borrowAPY = res.toNumber()}));
     promises.push(this.getCollateralRatio().then((res: BigNumber) => {collateralRatio = res.toNumber()}));
-
+    
+    var rewardSpeed: TokenAmount, plyPrice: BigNumber, underlyingPrice: BigNumber;
+    promises.push(this._comptroller.rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address).then((res) => {
+      rewardSpeed = new TokenAmount(
+        PLYToken,
+        res.toString()
+      )
+    }));
+    promises.push(fetchPrice(networkAddresses.tokens.PLY, this._networkConnection.provider).then((res) => {plyPrice = res}));
+    promises.push(fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {underlyingPrice = res}));
+    
     await Promise.all(promises);
+    
+    var borrowPlyApy = calcLMRewardApr(plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+      underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()), ONE_YEAR);
+    var depositPlyApy = calcLMRewardApr(plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+      underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()), ONE_YEAR);
+
     return {
       auTokenAddress: this.auToken.address,
       totalTokenDeposited: totalDeposited!,
       totalTokenBorrowed: totalBorrowed!,
       depositApy: depositAPY!,
-      depositPlyApy: 0.18,
+      depositPlyApy: depositPlyApy.toNumber(), 
       borrowApy: borrowAPY!,
-      borrowPlyApy: 0.18,
+      borrowPlyApy: borrowPlyApy.toNumber(), 
       collateralRatio: collateralRatio!
     };
   }

package/src/constants.ts

@@ -67,13 +67,22 @@ export const networkAddresses: NetworkAddresses = {
     COMPTROLLER: "0xb51028d4f3fc69e3f9e3118ce067a4562c595aad",
     oracle: "0xf1ebfaa2af93f4d82215fd7817c1835853c62fb8",
     AURIFAIRLAUNCH: "0x7942874a9ef8059c5de259625a883dc61f03320d",
-    AURILENS: dummyAddress
+    AURILENS: '0xa2635a23a7688cd3acdd07713c4943b2f0f9082c'
   },
   tokens: {
     AURORA: "0x7a80df8230c5aa711e2702a275ab31aeb32754bf",
     PLY: "0x6f8a1daa158e08f75711a64e5a3073e959d688a6",
     AURPLY: dummyAddress
   }
+  // auTokens: [
+  //   {
+  //     address: "0x0222cd9f9079140d12980ffcb39851694533436c",
+  //     underlying: "0xb12bfca5a55806aaf64e99521918a4bf0fc40802"
+  //   },
+  //   {
+  //     address: 
+  //   }
+  // ]
 }
 
 export const BORROW_LIMIT_BUFFER = new BigNumber(0.95);
@@ -82,5 +91,7 @@ export const REWARDCLAIMSTART = 1673280000;
 
 export const ONE_DAY = 86400;
 
+export const ONE_YEAR = ONE_DAY * 365;
+
 export const AurPlyPid = 1;
 

package/src/priceFetcher.ts

@@ -7,9 +7,11 @@ import { PriceOracle } from "@aurigami/contracts/typechain";
 import { TokenAmount } from "./tokenAmount";
 import { Address } from "./types";
 import IUniswapV2PairABI from './abis/IUniswapV2Pair.json';
+import dummyABI from "./abis/dummy.json";
+
 const axios = require('axios')
 
-export async function fetchPriceFromCoingecko(id: string): Promise<BigNumber> {
+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) => {
@@ -19,11 +21,11 @@ export async function fetchPriceFromCoingecko(id: string): Promise<BigNumber> {
     return new BigNumber(price[id].usd)
 }
 
-export async function fetchBasicTokenPrice(address: Address): Promise<BigNumber> {
+export async function fetchPriceFromCoingecko(address: Address): Promise<BigNumber> {
     if (isSameAddress(address, networkAddresses.tokens.AURORA)) {
-        return fetchPriceFromCoingecko('aurora-near');
+        return fetchPriceFromCoingeckoAPI('aurora-near');
     } else {
-        throw Error(`Unknown token ${address} in fetchBasicTokenPrice`);
+        throw Error(`Unknown token ${address} in fetchPriceFromCoingecko`);
     }
 }
 
@@ -44,8 +46,8 @@ export async function fetchLPPositions(LPAddress: Address, provider: providers.P
     return {
         token0: values[0],
         token1: values[1],
-        reserve0: values[2]._reserve0,
-        reserve1: values[2]._reserve1,
+        reserve0: values[2].reserve0,
+        reserve1: values[2].reserve1,
         totalSupply: values[3]
     }
 }
@@ -66,10 +68,27 @@ export async function fetchLPPrice(address: Address, provider: providers.Provide
       }
     }
   }
-export async function fetchPriceFromOracle(auTokenAddress: Address, underlyingDecimals: number, provider: providers.Provider): Promise<BigNumber> {
+
+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 new BigNumber(rawPrice.toString()).div(decimalFactor(36 - underlyingDecimals));
+    return processPriceFromOracle(rawPrice, underlyingDecimal)
+}
+
+export async function fetchUnderlyingTokensPrices(provider: providers.Provider) {
+    const auriLens: Contract = new Contract(networkAddresses.misc.AURILENS, dummyABI.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 fetchPrice(address: Address, provider: providers.Provider): Promise<BigNumber> {
@@ -81,7 +100,7 @@ export async function fetchPrice(address: Address, provider: providers.Provider)
     } else if (isSameAddress(address, networkAddresses.misc.AUPLYLP)) {
         return fetchLPPrice(address, provider);
     } else {
-        return fetchBasicTokenPrice(address);
+        return fetchPriceFromCoingecko(address);
     }
 }
 export async function fetchValuation(tokenAmount: TokenAmount, provider: providers.Provider, price?: BigNumber): Promise<BigNumber> {

package/src/types.ts

@@ -1,6 +1,10 @@
 import type { providers, Signer } from 'ethers';
 import { TokenAmount } from './tokenAmount';
 
+export enum ComptrollerRewardType {
+  PLY = 0,
+  AURORA
+};
 export type NetworkConnection = {
   provider: providers.Provider,
   signer?: Signer