@aurigami/sdk 1.4.7 → 1.5.0-dummy

package/dist/test/constants.d.ts

@@ -0,0 +1,6 @@
+import { ethers, Signer } from 'ethers';
+export declare const AVAX_DEFAULT_PROVIDER_URL = "https://api.avax.network/ext/bc/C/rpc";
+export declare const AVAX_DEFAULT_PROVIDER: ethers.providers.JsonRpcProvider;
+export declare const AURORA_DEFAULT_PROVIDER_URL: string;
+export declare const AURORA_DEFAULT_PROVIDER: ethers.providers.JsonRpcProvider;
+export declare const AURORA_DEFAULT_SIGNER: Signer;

package/dist/test-hardhat/helper.d.ts

@@ -0,0 +1,6 @@
+import { Address } from '../src/types';
+import { AuriFairLaunch } from '@aurigami/contracts/typechain';
+export declare function impersonate(address: Address): Promise<void>;
+export declare function prepareERC20Balance(tokenAddress: Address, tokenHolder: Address, receiver: Address, amount?: string): Promise<void>;
+export declare function getFairLaunchContract(): Promise<AuriFairLaunch>;
+export declare function createStakingPool(stakeToken: Address): Promise<void>;

package/dist/token.d.ts

@@ -4,4 +4,4 @@ export declare class Token {
     constructor(address: string, decimals: number);
 }
 export declare const PLYToken: Token;
-export declare const AURPLYToken: Token;
+export declare const PLYUSDCToken: Token;

package/dist/types.d.ts

@@ -13,6 +13,10 @@ export declare type CurrencyAmount = {
     currency: string;
     amount: string;
 };
+export declare type TokenValuation = {
+    tokenAmount: TokenAmount;
+    currencyAmount: CurrencyAmount;
+};
 export declare type MoneyMarketDetails = {
     auTokenAddress: string;
     totalTokenDeposited: TokenAmount;
@@ -31,18 +35,18 @@ export declare type MoneyMarketDetails = {
 export declare type UserDetails = {
     markets: UserMarketDetails[];
     borrowLimit: CurrencyAmount;
-    accruedPly: TokenAmount;
-    lockedPly: TokenAmount;
+    userLockingDetails: UserLockingDetails;
     borrowableAmount: CurrencyAmount;
 };
-export declare type LockingDetails = {
+export declare type UserLockingDetails = {
     vestingStart: number;
     currentUnlockPortion: number;
+    accruedPly: TokenAmount;
+    currentPly: TokenAmount;
+    currentPulp: TokenAmount;
     nextUnlockPortion: number;
-};
-export declare type PlyAuroraPool = {
-    totalStakedLiquidity: CurrencyAmount;
-    apy: number;
+    nextPly: TokenAmount;
+    nextPulp: TokenAmount;
 };
 export declare type UserMarketDetails = {
     market: string;
@@ -53,8 +57,8 @@ export declare type UserMarketDetails = {
     collateralRatio: number;
     underlyingPrice: string;
 };
-export declare type PlyAuroraPoolDetails = {
-    totalStakedLiquidity: TokenAmount;
+export declare type PlyUsdcPoolDetails = {
+    totalStakedLiquidity: TokenValuation;
     apy: string;
 };
 export declare enum MarketAction {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.4.7",
+  "version": "1.5.0-dummy",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -13,8 +13,8 @@
   "scripts": {
     "start": "tsdx watch",
     "build": "tsdx build",
-    "test": "tsdx test",
-    "test-hardhat": "env TS_NODE_PROJECT=\"tsconfig.test.json\" yarn hardhat test",
+    "test": "tsdx test --no-cache",
+    "w-hardhat": "env TS_NODE_PROJECT=\"tsconfig.test.json\" yarn hardhat",
     "lint": "tsdx lint",
     "prepare": "tsdx build",
     "size": "size-limit",
@@ -58,7 +58,7 @@
     "typescript": "^4.5.4"
   },
   "dependencies": {
-    "@aurigami/contracts": "2.7.1",
+    "@aurigami/contracts": "3.0.1",
     "@nomiclabs/hardhat-ethers": "^2.0.5",
     "@nomiclabs/hardhat-etherscan": "^3.0.3",
     "@nomiclabs/hardhat-waffle": "^2.0.3",

package/src/Papermill.ts

@@ -0,0 +1,162 @@
+import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
+import { NetworkConnection, Address, UserLockingDetails } from './types';
+import { Contract, BigNumber as BN } from 'ethers';
+import AuriFairLaunchABI from "@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json";
+import PulpABI from '@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json';
+import EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
+import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
+import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
+import { AuriFairLaunch, AuriLens, Comptroller, IERC20, PULP } from "@aurigami/contracts/typechain";
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { networkAddresses, ONE_DAY, ALL_STAKING_POOLS, REWARD_CLAIM_START } from "./constants";
+import { getCurrentTimestamp } from './helpers';
+import { Token } from './token';
+import { TokenAmount } from './tokenAmount';
+import { getDecimal } from './helpers';
+import BigNumber from 'bignumber.js';
+
+
+export class PapermillRead extends BlockchainEntityRead {
+  public plyToken: Token;
+  public pulpToken: Token;
+
+  protected _ply: IERC20;
+  protected _pulp: PULP;
+  protected _comptroller: Comptroller;
+  protected _auriFairLaunch: AuriFairLaunch;
+  protected _auriLens: AuriLens;
+
+  constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+
+    let plyAddress = networkAddresses.tokens.PLY;
+    let pulpAddress = networkAddresses.tokens.PULP;
+
+    this.plyToken = new Token(
+      plyAddress,
+      getDecimal(plyAddress),
+    );
+    this.pulpToken = new Token(
+      pulpAddress,
+      getDecimal(pulpAddress),
+    );
+
+    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._ply = new Contract(plyAddress, EIP20InterfaceABI.abi, networkConnection.provider) as IERC20;
+    this._pulp = new Contract(pulpAddress, PulpABI.abi, networkConnection.provider) as PULP;
+  }
+
+  public async getPlyBalance(userAddress: Address): Promise<TokenAmount> {
+    const plyBalance = await this._ply.balanceOf(userAddress);
+    return new TokenAmount(this.plyToken, plyBalance.toString());
+  }
+
+  public async getPulpBalance(userAddress: Address): Promise<TokenAmount> {
+    const pulpBalance = await this._pulp.balanceOf(userAddress);
+    return new TokenAmount(this.pulpToken, pulpBalance.toString());
+  }
+
+  /**
+   * Get all unclaimed PLY reward of the user in all markets + all staking pools
+   */
+  public async getUnclaimedPlyReward(userAddress: Address): Promise<TokenAmount> {
+    let rewardBalancesMetadata = await this._auriLens.callStatic.claimRewards(
+      this._comptroller.address,
+      this._auriFairLaunch.address,
+      ALL_STAKING_POOLS,
+      {from: userAddress}
+    );
+
+    return new TokenAmount(this.plyToken, rewardBalancesMetadata.plyAccrured.toString());
+  }
+
+  /**
+   * Get all locking details of the user in all markets + all staking pools
+   */
+  public async getLockingDetails(userAddress: Address): Promise<UserLockingDetails> {
+    const currentTime = getCurrentTimestamp();
+    const currentWeek = BN.from(currentTime - REWARD_CLAIM_START).div(7 * ONE_DAY).toNumber();
+    const denominator = BN.from(10000);
+    var promises: any[] = [];
+
+    promises.push(this._auriLens.getPercentLock(this._pulp.address, userAddress, currentWeek));
+    promises.push(this._auriLens.getPercentLock(this._pulp.address, userAddress, currentWeek + 1));
+    promises.push(this.getUnclaimedPlyReward(userAddress));
+
+    var values: any[] = await Promise.all(promises);
+
+    let percentLockCurrentWeek = BN.from(values[0]);
+    let percentLockNextWeek = BN.from(values[1]);
+    let totalRewards = values[2] as TokenAmount;
+
+    let [
+      pulpAmountCurrentWeek,
+      plyAmountCurrentWeek
+    ] = await this._pulp.calcLockAmount(userAddress, totalRewards.rawAmount());
+
+
+    // Predict next week lock amount = totalRewards * percentLock next week
+    // This doesn't take (the reward that user might earn in the next week) into account
+    let plyAmountNextWeek = percentLockNextWeek.mul(totalRewards.rawAmount()).div(denominator);
+    let pulpAmountNextWeek = BN.from(totalRewards.rawAmount()).sub(plyAmountNextWeek);
+
+    // we need to divide these two number by 10000 and multiple by 100 to get the percentage
+    // I need to use BigNumber to do this because BN of ethers.js doesn't support floating point
+    let currentUnlockPortion = denominator.sub(percentLockCurrentWeek).toString();
+    let nextUnlockPortion = denominator.sub(percentLockNextWeek).toString();
+
+    return {
+      vestingStart: REWARD_CLAIM_START,
+      currentUnlockPortion: new BigNumber(currentUnlockPortion).dividedBy(100).toNumber(),
+      accruedPly: totalRewards,
+      currentPly: new TokenAmount(this.plyToken, plyAmountCurrentWeek.toString()),
+      currentPulp: new TokenAmount(this.pulpToken, pulpAmountCurrentWeek.toString()),
+      //
+      nextUnlockPortion: new BigNumber(nextUnlockPortion).dividedBy(100).toNumber(),
+      nextPly: new TokenAmount(this.plyToken, plyAmountNextWeek.toString()),
+      nextPulp: new TokenAmount(this.pulpToken, pulpAmountNextWeek.toString()),
+    };
+  }
+}
+
+export class PapermillReadWrite extends PapermillRead {
+
+  constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+  }
+
+  /**
+   * Redeem PLY from PULP and transfer PLY to another address
+   * @param recipient Address that will receive the PLY.
+   * @param amount Amount of PULP to be converted to PLY.
+   * Set to ethers.constants.MaxUint256 for max redeem.
+   */
+  public async redeem(recipient: Address, amount: TokenAmount): Promise<TransactionResponse> {
+    return this._pulp.redeem(recipient, amount.rawAmount());
+  }
+
+  /**
+   * Redeem PLY from PULP and transfer PLY to msg.sender
+   * @param amount Amount of PULP to be converted to PLY.
+   * Set to ethers.constants.MaxUint256 for max redeem.
+   */
+  public async selfRedeem(amount: TokenAmount): Promise<TransactionResponse> {
+    let msgSender: string = await this._networkConnection.signer!.getAddress();
+    return this.redeem(msgSender, amount);
+  }
+}
+
+export class Papermill extends BlockchainEntity {
+  constructor() {
+    super();
+  }
+  public read(networkConnection: NetworkConnection): PapermillRead {
+    return new PapermillRead(networkConnection);
+  }
+
+  public readWrite(networkConnection: NetworkConnection): PapermillReadWrite {
+    return new PapermillReadWrite(networkConnection);
+  }
+}

package/src/SDK.ts

@@ -1,62 +1,42 @@
 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 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;
-  protected _fakeComptroller: Comptroller;
   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;
-    this._fakeComptroller = new Contract(networkAddresses.misc.FAKE_COMPTROLLER, ComptrollerABI.abi, networkConnection.provider) as Comptroller;
-  }
-
-  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(),
-    };
   }
 
   public async getUserDetails(userAddress: string): Promise<UserDetails> {
@@ -80,7 +60,7 @@ export class SdkRead extends BlockchainEntityRead {
     }
 
     promises.push(this._comptroller.getAssetsIn(userAddress).then((res: string[]) => {assetsIn = res}));
-    
+
     await Promise.all(promises);
     var underlyingPrices = await Promise.all(pricePromises);
     var depositValues = []
@@ -99,20 +79,14 @@ export class SdkRead extends BlockchainEntityRead {
       return p;
     }, new BigNumber(0))
 
-    promises = new Array(3);
-    var accountLiquidity: [BN, BN], rewardBalancesMetadata, lockedAmount: BN;
-    promises[0] = this._fakeComptroller.getAccountLiquidity(userAddress);
-    promises[1] = this._auriLens.callStatic.claimAndGetRewardBalancesMetadata(this._comptroller.address, this._auriFairLaunch.address, [], {from: userAddress});
-    promises[2] = this._tokenLock.lockedAmounts(userAddress);
-    var values = await Promise.all(promises);
+    var accountLiquidity: [BN, BN] = await this._comptroller.getAccountLiquidity(userAddress);
 
-    accountLiquidity = values[0]; rewardBalancesMetadata = values[1]; lockedAmount = values[2];
     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
       borrowedvaluation = new BigNumber(0);
-    } 
-    
+    }
+
     const bufferedBorrowLimit: BigNumber = totalBorrowLimit.multipliedBy(BORROW_LIMIT_BUFFER);
     const minimumBorrowLimitAllowed = borrowedvaluation.div(BORROW_LIMIT_BUFFER);
 
@@ -128,7 +102,7 @@ export class SdkRead extends BlockchainEntityRead {
       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()) 
+      userMarketDetails[i].maxWithdrawableAmount = userMarketDetails[i].isCollateral && maxWithdrawCap.lt(userMarketDetails[i].depositBalance.formattedAmount())
       ?  new TokenAmount(
           moneyMarket.underlying,
           maxWithdrawCap.toFixed(24),
@@ -146,8 +120,7 @@ export class SdkRead extends BlockchainEntityRead {
         currency: "USD",
         amount: bufferedBorrowLimit.toFixed(DECIMAL_PRECISION)
       },
-      accruedPly: new TokenAmount(PLYToken, rewardBalancesMetadata.plyAccrued.toString()),
-      lockedPly: new TokenAmount(PLYToken, lockedAmount.toString()),
+      userLockingDetails: await new PapermillRead(this._networkConnection).getLockingDetails(userAddress),
       borrowableAmount: {
         currency: "USD",
         amount: borrowableAmount.toFixed(DECIMAL_PRECISION)
@@ -155,33 +128,47 @@ export class SdkRead extends BlockchainEntityRead {
     };
   }
 
-  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.rewardPerSecond;  
-    }));
-    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),
     };
   }
 
@@ -192,24 +179,43 @@ export class SdkRead extends BlockchainEntityRead {
       amount: price.toFixed(DECIMAL_PRECISION)
     }
   }
-  public async stakeBalanceOf(user: string): Promise<TokenAmount> {
-    const userInfo = await this._auriFairLaunch.getUserInfo(AurPlyPid, user);
-    return new TokenAmount(
-      AURPLYToken,
+
+  /**
+   * 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
   }: {
     userMarketDetail: UserMarketDetails,
-    currentBorrowLimit: CurrencyAmount, 
-    currentBorrowValuation: CurrencyAmount, 
+    currentBorrowLimit: CurrencyAmount,
+    currentBorrowValuation: CurrencyAmount,
     action: MarketAction,
     tokenAmount?: TokenAmount
   }): HypotheticalStats {
@@ -245,19 +251,25 @@ export class SdkRead extends BlockchainEntityRead {
 }
 
 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]
+      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);
     return faucet.connect(this._networkConnection.signer!).drip();

package/src/constants.ts

@@ -66,34 +66,54 @@ export const networkAddresses: NetworkAddresses = {
   ],
   misc: {
     COMPTROLLER: "0x817af6cfAF35BdC1A634d6cC94eE9e4c68369Aeb".toLowerCase(),
-    FAKE_COMPTROLLER: "0x8072b287b6a95e1Db6C8404BBd78642387dFA16C".toLowerCase(),
     oracle: "0xC6e5185438e1730959c1eF3551059A3feC744E90".toLowerCase(),
-    AURIFAIRLAUNCH: "0x9F9ceE911509abC6Af899c12ED625B0A6580D6e6".toLowerCase(),
-    AURILENS: '0xC41a5C1625d492436600789469c1CE2eA20CEA6B'.toLowerCase(),
+    AURIFAIRLAUNCH: "0x6f068608573c840bB27b39458d7d87eB865e19Cc".toLowerCase(),
+    AURILENS: '0xFfdFfBDB966Cb84B50e62d70105f2Dbf2e0A1e70'.toLowerCase(),
     TOKENLOCK: '0xDACC02a4Ff16Ea3c1515AdbfdCeb7B1F448B79c8'.toLowerCase(),
     ETHREPAYHELPER: "0xa308A5003fA1A25BFdD9418FcEE51d48Dbe441e6".toLowerCase(),
     AURI_AIRDROP: "0x6C42aA5b128B62D6CCf357726D7d13F3888335EC".toLowerCase()
   },
   tokens: {
     AURORA: "0x8bec47865ade3b172a928df8f990bc7f2a3b9f79".toLowerCase(),
-    PLY: "0x981bD5832EAB9C8F607940E0e9faCBf8C09ee20a".toLowerCase(),
+    PLY: "0x09c9d464b58d96837f8d8b6f4d9fe4ad408d3a4f".toLowerCase(),
     stNEAR: "0x07f9f7f963c5cd2bbffd30ccfb964be114332e30".toLowerCase(),
     USDC: '0xb12bfca5a55806aaf64e99521918a4bf0fc40802'.toLowerCase(),
     WNEAR: '0xC42C30aC6Cc15faC9bD938618BcaA1a1FaE8501d'.toLowerCase(),
     TRI: '0xFa94348467f64D5A457F75F8bc40495D33c65aBB'.toLowerCase(),
     META: '0xc21ff01229e982d7c8b8691163b0a3cb8f357453'.toLocaleLowerCase(),
-    AURPLY: dummyAddress.toLowerCase() // This is dummy
+    PULP: '0x04Ac48711BCdc45b4d223fb021E09DA73c71095e'.toLowerCase(),
+    PLYUSDC: '0x37cae2b29c18e05ece60111fa01d3ca217046016'.toLowerCase(),
   }
 }
 
-export const BORROW_LIMIT_BUFFER = new BigNumber(1);
+// All token that we can calculate the price via oracle + coingecko
+export const PRICE_WHITELISTED = new Set([
+  ...networkAddresses.auTokens.map(t => t.underlying),
+  networkAddresses.tokens.AURORA,
+  networkAddresses.tokens.TRI,
+  networkAddresses.tokens.META,
+  networkAddresses.tokens.stNEAR,
+]);
+
 
-export const REWARDCLAIMSTART = 1640995200;
+export const REWARD_CLAIM_START = 1651762800; // 5 May 2022 15:00:00 UTC
+
+export const BORROW_LIMIT_BUFFER = new BigNumber(1);
 
 export const ONE_DAY = 86400;
 export const ONE_YEAR = ONE_DAY * 365;
 
-export const AurPlyPid = 0;
+export const PlyUsdcPid = 0;
+export const PLYUSDCRewardTokens = [
+  '0x09C9D464b58d96837f8d8b6f4d9fE4aD408d3A4f', // PLY
+  '0xC42C30aC6Cc15faC9bD938618BcaA1a1FaE8501d', // WNEAR
+  '0x8BEc47865aDe3B172A928df8f990Bc7f2A3b9f79', // AURORA
+  '0xFa94348467f64D5A457F75F8bc40495D33c65aBB', // TRI
+]
+// could call RPC to get all the staking pools but it's not necessary for now
+// export const ALL_STAKING_POOLS = [PlyUsdcPid];
+// TODO: fix this
+export const ALL_STAKING_POOLS = [];
 export const INF = BN.from(2).pow(256).sub(1)
 
 

package/src/decimals.ts

@@ -1,6 +1,6 @@
 export const decimalRecords: Record<string, number> = {
   '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': 18,
-  '0x981bd5832eab9c8f607940e0e9facbf8c09ee20a': 18,
+  '0x09c9d464b58d96837f8d8b6f4d9fe4ad408d3a4f': 18,
   '0x3195949f267702723bc614cae037cdc8d1e94786': 8,
   '0xfa94348467f64d5a457f75f8bc40495d33c65abb': 18,
   '0x07f9f7f963c5cd2bbffd30ccfb964be114332e30': 24,
@@ -18,5 +18,7 @@ export const decimalRecords: Record<string, number> = {
   '0xae4fac24dcdae0132c6d04f564dcf059616e9423': 8,
   '0xce4166363e3a584dac84a47bcd3414b43efcdd1c': 8,
   '0xf4eb217ba2454613b15dbdea6e5f22276410e89e': 8,
-  '0xc21ff01229e982d7c8b8691163b0a3cb8f357453': 24
+  '0xc21ff01229e982d7c8b8691163b0a3cb8f357453': 24,
+  '0x04ac48711bcdc45b4d223fb021e09da73c71095e': 18, // PULP
+  '0x37cae2b29c18e05ece60111fa01d3ca217046016': 18, // PLYUSDC
 }

package/src/deployments/aurora_mainnet.json

@@ -1,9 +1,9 @@
 {
   "deployer": "0xb969526EBc8dd4b1d816Da846eE08180515fFBbC",
   "unitroller": "0x817af6cfAF35BdC1A634d6cC94eE9e4c68369Aeb",
-  "comptrollerImpl": "0x45F710Fc648A05f1ed32a72DD7C91c8e73f6b412",
+  "comptrollerImpl": "0x559c68b1276d070CB9d6Da75ECeA90FFB6497b18",
   "comptroller": "0x817af6cfAF35BdC1A634d6cC94eE9e4c68369Aeb",
-  "PLY": "0x981bD5832EAB9C8F607940E0e9faCBf8C09ee20a",
+  "PLY": "0x09c9d464b58d96837f8d8b6f4d9fe4ad408d3a4f",
   "jumpRateModel": "0x0Bc03bd8d4aF1e8bab2194860268F5774C9d400a",
   "oracle": "0xC6e5185438e1730959c1eF3551059A3feC744E90",
   "auTokens": {
@@ -17,10 +17,14 @@
     "AURORA": "0x8888682E24dd4Df7B7Ff2B91fccB575737E433bf",
     "TRI": "0x6Ea6C03061bDdCE23d4Ec60B6E6e880c33d24dca"
   },
-  "tokenLock": "0xDACC02a4Ff16Ea3c1515AdbfdCeb7B1F448B79c8",
-  "fairLaunch": "0x9F9ceE911509abC6Af899c12ED625B0A6580D6e6",
-  "auriLens": "0xC41a5C1625d492436600789469c1CE2eA20CEA6B",
+  "fairLaunch": "0x6f068608573c840bB27b39458d7d87eB865e19Cc",
+  "auriLens": "0xFfdFfBDB966Cb84B50e62d70105f2Dbf2e0A1e70",
+  "auriLensImpl": "0x5Dd06745574b6E40F53E90468e5866fFB37173a0",
   "ethRepayHelper": "0xa308A5003fA1A25BFdD9418FcEE51d48Dbe441e6",
   "configReader": "0x347B321c466663D6A0fE9C0ccfCF8cEa86F8ecD3",
+  "auriAirdropImpl": "0x94cdA0Da833b384B901d33D5c56FccDE21D5E6e7",
+  "auriAirdrop": "0x6C42aA5b128B62D6CCf357726D7d13F3888335EC",
+  "ply_usdc_lp": "0x37cAe2B29c18E05ece60111Fa01d3ca217046016",
+  "PULP": "0x04Ac48711BCdc45b4d223fb021E09DA73c71095e",
   "test": {}
-}
+}