@aurigami/sdk 1.4.8 → 1.5.0-dummy-1

package/src/SDK.ts

@@ -1,65 +1,82 @@
 import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
 import {
-  LockingDetails,
-  PlyAuroraPoolDetails,
+  PlyUsdcPoolDetails,
   NetworkConnection,
   UserDetails,
   UserMarketDetails,
   Address,
   CurrencyAmount,
   HypotheticalStats,
-  MarketAction
+  MarketAction,
+  TokenValuation,
 } from './types';
-import { networkAddresses, BORROW_LIMIT_BUFFER, DECIMAL_PRECISION, REWARDCLAIMSTART, ONE_DAY, AurPlyPid } 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, ethers, providers } from 'ethers';
-import { isSameAddress, decimalFactor, getCurrentTimestamp, calcLMRewardApr } from './helpers';
+import { Contract, BigNumber as BN } from 'ethers';
+import {
+  isSameAddress,
+  decimalFactor,
+  calcLMRewardApr,
+  getDecimal,
+} from './helpers';
 import { MoneyMarketRead } from './MoneyMarket';
-import { fetchValuation, fetchPrice, calcValuation } from './priceFetcher';
-import { AuriFairLaunch, Comptroller, TokenLock, AuriLens } 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 { AURPLYToken, PLYToken, Token } from './token';
+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 TokenLockABI from "@aurigami/contracts/artifacts/contracts/TokenLock.sol/TokenLock.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 _tokenLock: TokenLock;
   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._tokenLock = new Contract(networkAddresses.misc.TOKENLOCK, TokenLockABI.abi, networkConnection.provider) as TokenLock;
-    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 getLockingDetails(): Promise<LockingDetails> {
-    const currentTime = getCurrentTimestamp();
-    const currentWeek = BN.from(currentTime - REWARDCLAIMSTART).div(7 * ONE_DAY).toNumber();
-    const denominator = 10000;
-    var promises = [];
-    promises.push(this._tokenLock.percentageLock(currentWeek));
-    promises.push(this._tokenLock.percentageLock(currentWeek + 1).catch((err: any) => {return denominator}));
-    var values: string[] = await Promise.all(promises).then((res) => {
-      return res.map((v) => {return v.toString()})
-    });
-    return {
-      vestingStart: REWARDCLAIMSTART, // 10 Jan 2023
-      currentUnlockPortion: (new BigNumber(denominator).minus(values[0])).div(denominator).toNumber(),
-      nextUnlockPortion: (new BigNumber(denominator).minus(values[1])).div(denominator).toNumber(),
-    };
+    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 = [];
@@ -67,197 +84,340 @@ 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))
-
-    promises = new Array(3);
-    var accountLiquidity: [BN, BN], rewardBalancesMetadata, lockedAmount: BN;
-    promises[0] = this._comptroller.getAccountLiquidity(userAddress);
-    promises[1] = this._auriLens.callStatic.claimRewards(this._comptroller.address, this._auriFairLaunch.address, [], {from: userAddress});
-    promises[2] = this._tokenLock.lockedAmounts(userAddress);
+    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)
+    );
 
-    [accountLiquidity, rewardBalancesMetadata, lockedAmount] = await Promise.all(promises);
+    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),
       },
-      accruedPly: new TokenAmount(PLYToken, rewardBalancesMetadata.plyAccrured.toString()),
-      lockedPly: new TokenAmount(PLYToken, lockedAmount.toString()),
+      userLockingDetails: await new PapermillRead(
+        this._networkConnection
+      ).getLockingDetails(userAddress),
       borrowableAmount: {
-        currency: "USD",
-        amount: borrowableAmount.toFixed(DECIMAL_PRECISION)
+        currency: 'USD',
+        amount: borrowableAmount.toFixed(DECIMAL_PRECISION),
       },
     };
   }
 
-  public async getPlyAuroraPoolDetails(): Promise<PlyAuroraPoolDetails> {
-    var stakedLiquidity: BN, rewardPerSecond: BN; 
-    var promises = [];
-    promises.push(this._auriFairLaunch.getPoolInfo(AurPlyPid).then((res) => {
-      stakedLiquidity =  res.totalStake;
-      rewardPerSecond = res.rewardPerSeconds[0];  
-    }));
-    await Promise.all(promises);
+  public async getPlyUsdcPoolDetails(): Promise<PlyUsdcPoolDetails> {
+    var stakedLiquidity: BN, rewardPerSeconds: BN[];
+    await this._auriFairLaunch.getPoolInfo(PlyUsdcPid).then((res) => {
+      stakedLiquidity = res.totalStake;
+      rewardPerSeconds = res.rewardPerSeconds;
+    });
 
-    promises = [];
-    var rewardPerSecondValuation: BigNumber, totalStakeValuation: BigNumber;
-    promises.push(fetchValuation(new TokenAmount(
-      PLYToken,
-      rewardPerSecond!.toString()
-    ), this._networkConnection.provider).then((res) => rewardPerSecondValuation = res));
-    promises.push(fetchValuation(new TokenAmount(
-      AURPLYToken,
+    let stakedLiquidityAmount = new TokenAmount(
+      PLYUSDCToken,
       stakedLiquidity!.toString()
-    ), this._networkConnection.provider).then((res) => totalStakeValuation = res));
-    await Promise.all(promises);
+    );
+
+    var promises = [];
+    for (let i = 0; i < rewardPerSeconds!.length; i++) {
+      let rewardTokenAddress = PLYUSDCRewardTokens[i];
+      let rewardToken = new Token(
+        rewardTokenAddress,
+        getDecimal(rewardTokenAddress)
+      );
+      let rewardPerSecond = rewardPerSeconds![i];
+      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)
+    );
+
+    var totalStakeValuation: BigNumber = await fetchValuation(
+      stakedLiquidityAmount,
+      this._networkConnection.provider
+    );
 
     return {
-      totalStakedLiquidity: new TokenAmount(
-        AURPLYToken,
-        stakedLiquidity!.toString()
-      ),
-      apy: calcLMRewardApr(rewardPerSecondValuation!, totalStakeValuation!, ONE_DAY * 365).toFixed(DECIMAL_PRECISION),
+      totalStakedLiquidity: {
+        tokenAmount: stakedLiquidityAmount,
+        currencyAmount: {
+          currency: 'USD',
+          amount: totalStakeValuation!.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),
+    };
   }
-  public async stakeBalanceOf(user: string): Promise<TokenAmount> {
-    const userInfo = await this._auriFairLaunch.getUserInfo(AurPlyPid, user);
-    return new TokenAmount(
-      AURPLYToken,
-      userInfo.amount.toString()
-    )
+
+  /**
+   * Get amount and value in $ of staked LP tokens
+   */
+  public async stakeBalanceOf(user: string): Promise<TokenValuation> {
+    const userInfo = await this._auriFairLaunch.getUserInfo(PlyUsdcPid, user);
+    let stakeAmount = new TokenAmount(PLYUSDCToken, userInfo.amount.toString());
+
+    return valuateToken(stakeAmount, this._networkConnection.provider);
+  }
+
+  /**
+   * 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 balance = await lpERC20.balanceOf(user);
+
+    return valuateToken(
+      new TokenAmount(PLYUSDCToken, balance.toString()),
+      this._networkConnection.provider
+    );
   }
 
   public calcHypotheticalStats({
-    userMarketDetail, 
+    userMarketDetail,
     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(),
+    };
   }
 }
 
 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,
-      [AurPlyPid]
-    );
+    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(AurPlyPid, 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(AurPlyPid, 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();
   }
 }