@aurigami/sdk 1.5.0-dummy → 1.5.0-dummy-2

package/src/SDK.ts

@@ -8,40 +8,75 @@ import {
   CurrencyAmount,
   HypotheticalStats,
   MarketAction,
-  TokenValuation
+  TokenValuation,
 } from './types';
-import { networkAddresses, BORROW_LIMIT_BUFFER, DECIMAL_PRECISION, ONE_DAY, PlyUsdcPid, ALL_STAKING_POOLS, PLYUSDCRewardTokens } from './constants';
+import {
+  networkAddresses,
+  BORROW_LIMIT_BUFFER,
+  DECIMAL_PRECISION,
+  ONE_DAY,
+  PlyUsdcPid,
+  ALL_STAKING_POOLS,
+  PLYUSDCRewardTokens,
+} from './constants';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import { Contract, BigNumber as BN } from 'ethers';
-import { isSameAddress, decimalFactor, calcLMRewardApr, getDecimal } from './helpers';
+import {
+  isSameAddress,
+  decimalFactor,
+  calcLMRewardApr,
+  getDecimal,
+} from './helpers';
 import { MoneyMarketRead } from './MoneyMarket';
-import { fetchValuation, fetchPrice, calcValuation, valuateToken } from './priceFetcher';
-import { AuriFairLaunch, Comptroller, AuriLens, IERC20 } from '@aurigami/contracts/typechain';
+import {
+  fetchValuation,
+  fetchPrice,
+  calcValuation,
+  valuateToken,
+} from './priceFetcher';
+import {
+  AuriFairLaunch,
+  Comptroller,
+  AuriLens,
+  IERC20,
+} from '@aurigami/contracts/typechain';
 import { TokenAmount } from './tokenAmount';
 import { PLYUSDCToken, PLYToken, Token } from './token';
 import BigNumber from 'bignumber.js';
 import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
 import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
-import AuriFairLaunchABI from "@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json";
-import FaucetABI from "@aurigami/contracts/artifacts/contracts/mock/Faucet.sol/Faucet.json";
+import AuriFairLaunchABI from '@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json';
+import FaucetABI from '@aurigami/contracts/artifacts/contracts/mock/Faucet.sol/Faucet.json';
 import EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
 import { PapermillRead } from './Papermill';
 
 export class SdkRead extends BlockchainEntityRead {
-
   protected _comptroller: Comptroller;
   protected _auriFairLaunch: AuriFairLaunch;
   protected _auriLens: AuriLens;
   constructor(networkConnection: NetworkConnection) {
     super(networkConnection);
-    this._comptroller = new Contract(networkAddresses.misc.COMPTROLLER, ComptrollerABI.abi, networkConnection.provider) as Comptroller;
-    this._auriFairLaunch = new Contract(networkAddresses.misc.AURIFAIRLAUNCH, AuriFairLaunchABI.abi, networkConnection.provider) as AuriFairLaunch;
-    this._auriLens = new Contract(networkAddresses.misc.AURILENS, AuriLensABI.abi, networkConnection.provider) as AuriLens;
+    this._comptroller = new Contract(
+      networkAddresses.misc.COMPTROLLER,
+      ComptrollerABI.abi,
+      networkConnection.provider
+    ) as Comptroller;
+    this._auriFairLaunch = new Contract(
+      networkAddresses.misc.AURIFAIRLAUNCH,
+      AuriFairLaunchABI.abi,
+      networkConnection.provider
+    ) as AuriFairLaunch;
+    this._auriLens = new Contract(
+      networkAddresses.misc.AURILENS,
+      AuriLensABI.abi,
+      networkConnection.provider
+    ) as AuriLens;
   }
 
   public async getUserDetails(userAddress: string): Promise<UserDetails> {
     const marketCount = networkAddresses.auTokens.length;
-    var userMarketDetails: UserMarketDetails[] = [], assetsIn: string[];
+    var userMarketDetails: UserMarketDetails[] = [],
+      assetsIn: string[];
     var promises = [];
     var totalBorrowLimit = new BigNumber(0);
     var pricePromises = [];
@@ -49,81 +84,142 @@ export class SdkRead extends BlockchainEntityRead {
       const userMarketDetail: UserMarketDetails = {} as UserMarketDetails;
       userMarketDetails.push(userMarketDetail);
       userMarketDetail.market = auToken.underlying;
-      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(this._networkConnection, auToken.address, auToken.underlying);
-      promises.push(moneyMarket.getUserDepositBalance(userAddress).then((res: TokenAmount) => {userMarketDetail.depositBalance = res}));
-      promises.push(moneyMarket.getUserBorrowBalance(userAddress).then((res: TokenAmount) => {userMarketDetail.borrowBalance = res}));
-      promises.push(moneyMarket.getCollateralRatio().then((res: BigNumber) => {userMarketDetail.collateralRatio = res.toNumber()}));
-      pricePromises.push(fetchPrice(moneyMarket.underlying.address, this._networkConnection.provider).then((res) => {
-        userMarketDetail.underlyingPrice = res.toString();
-        return res;
-      }));
+      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
+        this._networkConnection,
+        auToken.address,
+        auToken.underlying
+      );
+      promises.push(
+        moneyMarket
+          .getUserDepositBalance(userAddress)
+          .then((res: TokenAmount) => {
+            userMarketDetail.depositBalance = res;
+          })
+      );
+      promises.push(
+        moneyMarket
+          .getUserBorrowBalance(userAddress)
+          .then((res: TokenAmount) => {
+            userMarketDetail.borrowBalance = res;
+          })
+      );
+      promises.push(
+        moneyMarket.getCollateralRatio().then((res: BigNumber) => {
+          userMarketDetail.collateralRatio = res.toNumber();
+        })
+      );
+      pricePromises.push(
+        fetchPrice(
+          moneyMarket.underlying.address,
+          this._networkConnection.provider
+        ).then((res) => {
+          userMarketDetail.underlyingPrice = res.toString();
+          return res;
+        })
+      );
     }
 
-    promises.push(this._comptroller.getAssetsIn(userAddress).then((res: string[]) => {assetsIn = res}));
+    promises.push(
+      this._comptroller.getAssetsIn(userAddress).then((res: string[]) => {
+        assetsIn = res;
+      })
+    );
 
     await Promise.all(promises);
     var underlyingPrices = await Promise.all(pricePromises);
-    var depositValues = []
-    for (var i = 0; i < marketCount; i ++) {
+    var depositValues = [];
+    for (var i = 0; i < marketCount; i++) {
       const auToken = networkAddresses.auTokens[i];
-      if (assetsIn!.find((auAddress: Address) => isSameAddress(auToken.address, auAddress)) !== undefined) {
+      if (
+        assetsIn!.find((auAddress: Address) =>
+          isSameAddress(auToken.address, auAddress)
+        ) !== undefined
+      ) {
         userMarketDetails[i].isCollateral = true;
       } else {
         userMarketDetails[i].isCollateral = false;
       }
-      depositValues.push(calcValuation(userMarketDetails[i].depositBalance,  underlyingPrices[i]));
+      depositValues.push(
+        calcValuation(userMarketDetails[i].depositBalance, underlyingPrices[i])
+      );
     }
 
-    totalBorrowLimit = depositValues.reduce((p: BigNumber, v: BigNumber, index: number)=> {
-      if (userMarketDetails[index].isCollateral) return p.plus(v.multipliedBy(userMarketDetails[index].collateralRatio));
-      return p;
-    }, new BigNumber(0))
+    totalBorrowLimit = depositValues.reduce(
+      (p: BigNumber, v: BigNumber, index: number) => {
+        if (userMarketDetails[index].isCollateral)
+          return p.plus(
+            v.multipliedBy(userMarketDetails[index].collateralRatio)
+          );
+        return p;
+      },
+      new BigNumber(0)
+    );
 
-    var accountLiquidity: [BN, BN] = await this._comptroller.getAccountLiquidity(userAddress);
+    var accountLiquidity: [BN, BN] =
+      await this._comptroller.getAccountLiquidity(userAddress);
 
-    var borrowedvaluation: BigNumber = totalBorrowLimit.minus(new BigNumber(accountLiquidity[0].toString()).div(decimalFactor(18)));
+    var borrowedvaluation: BigNumber = totalBorrowLimit.minus(
+      new BigNumber(accountLiquidity[0].toString()).div(decimalFactor(18))
+    );
 
-    if (borrowedvaluation.lt("0.00001")) { // Igore dust, dust could be the result of network delay causing collateral valuation calc to be different on vs off chain
+    if (borrowedvaluation.lt('0.00001')) {
+      // Igore dust, dust could be the result of network delay causing collateral valuation calc to be different on vs off chain
       borrowedvaluation = new BigNumber(0);
     }
 
-    const bufferedBorrowLimit: BigNumber = totalBorrowLimit.multipliedBy(BORROW_LIMIT_BUFFER);
-    const minimumBorrowLimitAllowed = borrowedvaluation.div(BORROW_LIMIT_BUFFER);
+    const bufferedBorrowLimit: BigNumber =
+      totalBorrowLimit.multipliedBy(BORROW_LIMIT_BUFFER);
+    const minimumBorrowLimitAllowed =
+      borrowedvaluation.div(BORROW_LIMIT_BUFFER);
 
     var borrowableAmount: BigNumber;
     if (bufferedBorrowLimit.lte(borrowedvaluation)) {
-      borrowableAmount = new BigNumber(0)
+      borrowableAmount = new BigNumber(0);
     } else {
       borrowableAmount = bufferedBorrowLimit.minus(borrowedvaluation);
     }
 
-    for (var i = 0; i < marketCount; i ++) {
+    for (var i = 0; i < marketCount; i++) {
       const auToken = networkAddresses.auTokens[i];
-      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(this._networkConnection, auToken.address, auToken.underlying);
-      const borrowLimitMargin = totalBorrowLimit.minus(minimumBorrowLimitAllowed).gt(0) ? totalBorrowLimit.minus(minimumBorrowLimitAllowed) : new BigNumber(0);
-      const maxWithdrawCap: BigNumber = borrowLimitMargin.div(userMarketDetails[i].collateralRatio).div(underlyingPrices[i]);
-      userMarketDetails[i].maxWithdrawableAmount = userMarketDetails[i].isCollateral && maxWithdrawCap.lt(userMarketDetails[i].depositBalance.formattedAmount())
-      ?  new TokenAmount(
-          moneyMarket.underlying,
-          maxWithdrawCap.toFixed(24),
-          false
-        )
-      : new TokenAmount(
-          moneyMarket.underlying,
-          userMarketDetails[i].depositBalance.rawAmount()
-        );
+      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
+        this._networkConnection,
+        auToken.address,
+        auToken.underlying
+      );
+      const borrowLimitMargin = totalBorrowLimit
+        .minus(minimumBorrowLimitAllowed)
+        .gt(0)
+        ? totalBorrowLimit.minus(minimumBorrowLimitAllowed)
+        : new BigNumber(0);
+      const maxWithdrawCap: BigNumber = borrowLimitMargin
+        .div(userMarketDetails[i].collateralRatio)
+        .div(underlyingPrices[i]);
+      userMarketDetails[i].maxWithdrawableAmount =
+        userMarketDetails[i].isCollateral &&
+        maxWithdrawCap.lt(userMarketDetails[i].depositBalance.formattedAmount())
+          ? new TokenAmount(
+              moneyMarket.underlying,
+              maxWithdrawCap.toFixed(24),
+              false
+            )
+          : new TokenAmount(
+              moneyMarket.underlying,
+              userMarketDetails[i].depositBalance.rawAmount()
+            );
     }
 
     return {
       markets: userMarketDetails,
       borrowLimit: {
-        currency: "USD",
-        amount: bufferedBorrowLimit.toFixed(DECIMAL_PRECISION)
+        currency: 'USD',
+        amount: bufferedBorrowLimit.toFixed(DECIMAL_PRECISION),
       },
-      userLockingDetails: await new PapermillRead(this._networkConnection).getLockingDetails(userAddress),
+      userLockingDetails: await new PapermillRead(
+        this._networkConnection
+      ).getLockingDetails(userAddress),
       borrowableAmount: {
-        currency: "USD",
-        amount: borrowableAmount.toFixed(DECIMAL_PRECISION)
+        currency: 'USD',
+        amount: borrowableAmount.toFixed(DECIMAL_PRECISION),
       },
     };
   }
@@ -143,16 +239,22 @@ export class SdkRead extends BlockchainEntityRead {
     var promises = [];
     for (let i = 0; i < rewardPerSeconds!.length; i++) {
       let rewardTokenAddress = PLYUSDCRewardTokens[i];
-      let rewardToken = new Token(rewardTokenAddress, getDecimal(rewardTokenAddress));
+      let rewardToken = new Token(
+        rewardTokenAddress,
+        getDecimal(rewardTokenAddress)
+      );
       let rewardPerSecond = rewardPerSeconds![i];
-      promises.push(fetchValuation(
+      promises.push(
+        fetchValuation(
           new TokenAmount(rewardToken, rewardPerSecond!.toString()),
           this._networkConnection.provider
-      ));
+        )
+      );
     }
 
     const rewardPerSecondValuation = (await Promise.all(promises)).reduce(
-      (p: BigNumber, v: BigNumber) => p.plus(v), new BigNumber(0)
+      (p: BigNumber, v: BigNumber) => p.plus(v),
+      new BigNumber(0)
     );
 
     var totalStakeValuation: BigNumber = await fetchValuation(
@@ -164,20 +266,27 @@ export class SdkRead extends BlockchainEntityRead {
       totalStakedLiquidity: {
         tokenAmount: stakedLiquidityAmount,
         currencyAmount: {
-          currency: "USD",
-          amount: totalStakeValuation!.toFixed(DECIMAL_PRECISION)
-        }
+          currency: 'USD',
+          amount: totalStakeValuation!.toFixed(DECIMAL_PRECISION),
+        },
       },
-      apy: calcLMRewardApr(rewardPerSecondValuation, totalStakeValuation, ONE_DAY * 365).toFixed(DECIMAL_PRECISION),
+      apy: calcLMRewardApr(
+        rewardPerSecondValuation,
+        totalStakeValuation,
+        ONE_DAY * 365
+      ).toFixed(DECIMAL_PRECISION),
     };
   }
 
   public async getTokenPrice(token: Token): Promise<CurrencyAmount> {
-    const price = await fetchPrice(token.address, this._networkConnection.provider);
+    const price = await fetchPrice(
+      token.address,
+      this._networkConnection.provider
+    );
     return {
-      currency: "USD",
-      amount: price.toFixed(DECIMAL_PRECISION)
-    }
+      currency: 'USD',
+      amount: price.toFixed(DECIMAL_PRECISION),
+    };
   }
 
   /**
@@ -185,10 +294,7 @@ export class SdkRead extends BlockchainEntityRead {
    */
   public async stakeBalanceOf(user: string): Promise<TokenValuation> {
     const userInfo = await this._auriFairLaunch.getUserInfo(PlyUsdcPid, user);
-    let stakeAmount = new TokenAmount(
-      PLYUSDCToken,
-      userInfo.amount.toString()
-    );
+    let stakeAmount = new TokenAmount(PLYUSDCToken, userInfo.amount.toString());
 
     return valuateToken(stakeAmount, this._networkConnection.provider);
   }
@@ -197,7 +303,11 @@ export class SdkRead extends BlockchainEntityRead {
    * Get amount and value in $ of LP token in user wallet
    */
   public async LpBalanceOf(user: string): Promise<TokenValuation> {
-    let lpERC20 = new Contract(networkAddresses.tokens.PLYUSDC, EIP20InterfaceABI.abi, this._networkConnection.provider) as IERC20;
+    let lpERC20 = new Contract(
+      networkAddresses.tokens.PLYUSDC,
+      EIP20InterfaceABI.abi,
+      this._networkConnection.provider
+    ) as IERC20;
     let balance = await lpERC20.balanceOf(user);
 
     return valuateToken(
@@ -211,42 +321,68 @@ export class SdkRead extends BlockchainEntityRead {
     currentBorrowLimit,
     currentBorrowValuation,
     action,
-    tokenAmount
+    tokenAmount,
   }: {
-    userMarketDetail: UserMarketDetails,
-    currentBorrowLimit: CurrencyAmount,
-    currentBorrowValuation: CurrencyAmount,
-    action: MarketAction,
-    tokenAmount?: TokenAmount
+    userMarketDetail: UserMarketDetails;
+    currentBorrowLimit: CurrencyAmount;
+    currentBorrowValuation: CurrencyAmount;
+    action: MarketAction;
+    tokenAmount?: TokenAmount;
   }): HypotheticalStats {
-    var newBorrowLimit = new BigNumber(currentBorrowLimit.amount), newBorrowValuation = new BigNumber(currentBorrowValuation.amount);
+    var newBorrowLimit = new BigNumber(currentBorrowLimit.amount),
+      newBorrowValuation = new BigNumber(currentBorrowValuation.amount);
     switch (action) {
       case MarketAction.EnableCollateral:
       case MarketAction.DisableCollateral:
-        var deltaBorrowLimit = calcValuation(userMarketDetail.depositBalance, new BigNumber(userMarketDetail.underlyingPrice)).multipliedBy(userMarketDetail.collateralRatio).multipliedBy(BORROW_LIMIT_BUFFER);
-        newBorrowLimit = action == MarketAction.EnableCollateral ? newBorrowLimit.plus(deltaBorrowLimit) : newBorrowLimit.minus(deltaBorrowLimit);
+        var deltaBorrowLimit = calcValuation(
+          userMarketDetail.depositBalance,
+          new BigNumber(userMarketDetail.underlyingPrice)
+        )
+          .multipliedBy(userMarketDetail.collateralRatio)
+          .multipliedBy(BORROW_LIMIT_BUFFER);
+        newBorrowLimit =
+          action == MarketAction.EnableCollateral
+            ? newBorrowLimit.plus(deltaBorrowLimit)
+            : newBorrowLimit.minus(deltaBorrowLimit);
         break;
 
       case MarketAction.Deposit:
       case MarketAction.Withdraw:
-        deltaBorrowLimit = calcValuation(tokenAmount!, new BigNumber(userMarketDetail.underlyingPrice)).multipliedBy(userMarketDetail.collateralRatio).multipliedBy(BORROW_LIMIT_BUFFER);
-        newBorrowLimit = action == MarketAction.Deposit ? newBorrowLimit.plus(deltaBorrowLimit) : newBorrowLimit.minus(deltaBorrowLimit);
+        deltaBorrowLimit = calcValuation(
+          tokenAmount!,
+          new BigNumber(userMarketDetail.underlyingPrice)
+        )
+          .multipliedBy(userMarketDetail.collateralRatio)
+          .multipliedBy(BORROW_LIMIT_BUFFER);
+        newBorrowLimit =
+          action == MarketAction.Deposit
+            ? newBorrowLimit.plus(deltaBorrowLimit)
+            : newBorrowLimit.minus(deltaBorrowLimit);
         break;
 
       case MarketAction.Borrow:
       case MarketAction.Repay:
-        var deltaBorrowValuation = calcValuation(tokenAmount!, new BigNumber(userMarketDetail.underlyingPrice));
-        newBorrowValuation = action == MarketAction.Borrow ? newBorrowValuation.plus(deltaBorrowValuation) : newBorrowValuation.minus(deltaBorrowValuation);
+        var deltaBorrowValuation = calcValuation(
+          tokenAmount!,
+          new BigNumber(userMarketDetail.underlyingPrice)
+        );
+        newBorrowValuation =
+          action == MarketAction.Borrow
+            ? newBorrowValuation.plus(deltaBorrowValuation)
+            : newBorrowValuation.minus(deltaBorrowValuation);
         break;
     }
     return {
       newBorrowLimit: {
         amount: newBorrowLimit!.toFixed(DECIMAL_PRECISION),
-        currency: "USD"
+        currency: 'USD',
       },
-      newBorrowUtilization: newBorrowLimit.eq(0) ? newBorrowValuation.eq(0) ? 0 : 9999.99
-        : newBorrowValuation!.div(newBorrowLimit!).toNumber()
-    }
+      newBorrowUtilization: newBorrowLimit.eq(0)
+        ? newBorrowValuation.eq(0)
+          ? 0
+          : 9999.99
+        : newBorrowValuation!.div(newBorrowLimit!).toNumber(),
+    };
   }
 }
 
@@ -255,23 +391,33 @@ export class SdkReadWrite extends SdkRead {
    * Claim PLY reward in all markets + staking pools
    */
   public async claim(): Promise<TransactionResponse> {
-    return this._auriLens.connect(this._networkConnection.signer!).claimRewards(
-      this._comptroller.address,
-      this._auriFairLaunch.address,
-      ALL_STAKING_POOLS,
-    );
+    return this._auriLens
+      .connect(this._networkConnection.signer!)
+      .claimRewards(
+        this._comptroller.address,
+        this._auriFairLaunch.address,
+        ALL_STAKING_POOLS
+      );
   }
 
   public async stake(amount: TokenAmount): Promise<TransactionResponse> {
-    return this._auriFairLaunch.connect(this._networkConnection.signer!).deposit(PlyUsdcPid, amount.rawAmount());
+    return this._auriFairLaunch
+      .connect(this._networkConnection.signer!)
+      .deposit(PlyUsdcPid, amount.rawAmount());
   }
 
   public async unstake(amount: TokenAmount): Promise<TransactionResponse> {
-    return this._auriFairLaunch.connect(this._networkConnection.signer!).withdraw(PlyUsdcPid, amount.rawAmount());
+    return this._auriFairLaunch
+      .connect(this._networkConnection.signer!)
+      .withdraw(PlyUsdcPid, amount.rawAmount());
   }
 
   public async faucetDrip(): Promise<TransactionResponse> {
-    const faucet = new Contract(networkAddresses.misc.FAUCET, FaucetABI.abi, this._networkConnection.provider);
+    const faucet = new Contract(
+      networkAddresses.misc.FAUCET,
+      FaucetABI.abi,
+      this._networkConnection.provider
+    );
     return faucet.connect(this._networkConnection.signer!).drip();
   }
 }