@aurigami/sdk 1.4.8 → 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.8",
+  "version": "1.5.0-dummy",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,7 +14,7 @@
     "start": "tsdx watch",
     "build": "tsdx build",
     "test": "tsdx test --no-cache",
-    "test-hardhat": "env TS_NODE_PROJECT=\"tsconfig.test.json\" yarn hardhat test",
+    "w-hardhat": "env TS_NODE_PROJECT=\"tsconfig.test.json\" yarn hardhat",
     "lint": "tsdx lint",
     "prepare": "tsdx build",
     "size": "size-limit",

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,44 @@
 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;
   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(),
-    };
-  }
-
   public async getUserDetails(userAddress: string): Promise<UserDetails> {
     const marketCount = networkAddresses.auTokens.length;
     var userMarketDetails: UserMarketDetails[] = [], assetsIn: string[];
@@ -78,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 = []
@@ -97,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._comptroller.getAccountLiquidity(userAddress);
-    promises[1] = this._auriLens.callStatic.claimRewards(this._comptroller.address, this._auriFairLaunch.address, [], {from: userAddress});
-    promises[2] = this._tokenLock.lockedAmounts(userAddress);
-
-    [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)));
 
     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);
 
@@ -126,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),
@@ -144,8 +120,7 @@ export class SdkRead extends BlockchainEntityRead {
         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)
@@ -153,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.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),
     };
   }
 
@@ -190,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 {
@@ -243,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

@@ -75,24 +75,45 @@ export const networkAddresses: NetworkAddresses = {
   },
   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/helpers.ts

@@ -6,6 +6,7 @@ import { BigNumber as BN, Contract, providers, utils } from "ethers";
 import { getQuery as getAuroraAPIQuery } from "./aurora-api-helpers";
 import { decimalRecords } from "./decimals";
 import { Address, NetworkConnection } from "./types";
+import assert from 'assert';
 
 export function formatObject(object: Object) {
   return JSON.stringify(object, null, '  ');
@@ -32,7 +33,9 @@ export function validateAndParseAddress(address: Address): Address {
 }
 
 export function getDecimal(address: Address): number {
-  return decimalRecords[address.toLowerCase()];
+  let addressLowercase = address.toLowerCase();
+  assert(decimalRecords[addressLowercase] != undefined, "Decimal not found for " + address);
+  return decimalRecords[addressLowercase];
 }
 
 export function calcLMRewardApr(rewardsValue: BigNumber, totalStakeValue: BigNumber, frequencyPerYear: number): BigNumber {

package/src/index.ts

@@ -17,3 +17,4 @@ export * from './tokenAmount';
 export * from './types';
 export * from './airdrop-lottery';
 export * from './transfer-event-query';
+export * from './Papermill';