@aurigami/sdk 1.6.3 → 1.6.5

package/src/contracts/MoneyMarket.ts

@@ -1,20 +1,11 @@
-import AuErc20ABI from '@aurigami/contracts/artifacts/contracts/AuErc20.sol/AuErc20.json';
-import AuETHABI from '@aurigami/contracts/artifacts/contracts/AuETH.sol/AuETH.json';
-import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
-import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
-import EthRepayHelperABI from '@aurigami/contracts/artifacts/contracts/EthRepayHelper.sol/EthRepayHelper.json';
-import {
-  AuErc20,
-  AuETH,
-  AuriLens,
-  Comptroller,
-  EthRepayHelper,
-} from '@aurigami/contracts/typechain';
+import { AuErc20, AuETH, EthRepayHelper } from '@aurigami/contracts/typechain';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import BigNumber from 'bignumber.js';
 import { BigNumber as BN, Contract } from 'ethers';
+import * as abis from '../abis';
 import * as consts from '../consts';
 import {
+  AuriEnv,
   BlockchainEntity,
   BlockchainEntityRead,
   PLYToken,
@@ -22,17 +13,8 @@ import {
   TokenAmount,
 } from '../entities';
 import * as helpers from '../helpers/';
-import {
-  calcValuation,
-  fetchPrice,
-  fetchValuation,
-} from '../helpers/priceFetcher';
-import {
-  Address,
-  ComptrollerRewardType,
-  MoneyMarketDetails,
-  NetworkConnection,
-} from '../types';
+import { calcValuation, fetchPrice, fetchValuation } from '../helpers/priceFetcher';
+import { Address, ComptrollerRewardType, MoneyMarketDetails, NetworkConnection } from '../types';
 
 type RewardSpeeds = {
   plyRewardSupplySpeed: BN;
@@ -44,56 +26,31 @@ type RewardSpeeds = {
 export class MoneyMarketRead extends BlockchainEntityRead {
   public underlying: Token;
   public auToken: AuErc20 | AuETH;
-  protected _comptroller: Comptroller;
-
-  protected _auriLens: AuriLens;
-  constructor(
-    networkConnection: NetworkConnection,
-    auToken: Address,
-    underlyingAsset: Address
-  ) {
+  protected env: AuriEnv;
+  constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
     super(networkConnection);
+    this.env = new AuriEnv(networkConnection);
     if (helpers.isSameAddress(underlyingAsset, consts.ETHAddress)) {
-      this.auToken = new Contract(
-        auToken,
-        AuETHABI.abi,
-        networkConnection.provider
-      ) as AuETH;
+      this.auToken = new Contract(auToken, abis.AuETHABI.abi, networkConnection.provider) as AuETH;
     } else {
       this.auToken = new Contract(
         auToken,
-        AuErc20ABI.abi,
+        abis.AuErc20ABI.abi,
         networkConnection.provider
       ) as AuErc20;
     }
-    this.underlying = new Token(
-      underlyingAsset,
-      helpers.getDecimal(underlyingAsset)
-    );
-    this._comptroller = new Contract(
-      consts.networkAddresses.misc.COMPTROLLER,
-      ComptrollerABI.abi,
-      networkConnection.provider
-    ) as Comptroller;
-    this._auriLens = new Contract(
-      consts.networkAddresses.misc.AURILENS,
-      AuriLensABI.abi,
-      networkConnection.provider
-    ) as AuriLens;
+    this.underlying = new Token(underlyingAsset, helpers.getDecimal(underlyingAsset));
   }
 
   protected async getRewardSpeeds(): Promise<RewardSpeeds> {
-    var speeds = await this._auriLens.getRewardSpeeds(
-      this._comptroller.address,
+    var speeds = await this.env.auriLens.getRewardSpeeds(
+      this.env.comptroller.address,
       this.auToken.address
     );
     return speeds;
   }
   public async getTotalTokenBorrowed(): Promise<TokenAmount> {
-    return new TokenAmount(
-      this.underlying,
-      (await this.auToken.totalBorrows()).toString()
-    );
+    return new TokenAmount(this.underlying, (await this.auToken.totalBorrows()).toString());
   }
   public async getTotalTokenDeposited(): Promise<TokenAmount> {
     var promises = [];
@@ -130,10 +87,8 @@ export class MoneyMarketRead extends BlockchainEntityRead {
   }
 
   public async getCollateralRatio(): Promise<BigNumber> {
-    return this._comptroller.markets(this.auToken.address).then((res: any) => {
-      return new BigNumber(res.collateralFactorMantissa.toString()).div(
-        helpers.decimalFactor(18)
-      );
+    return this.env.comptroller.markets(this.auToken.address).then((res: any) => {
+      return new BigNumber(res.collateralFactorMantissa.toString()).div(helpers.decimalFactor(18));
     });
   }
 
@@ -149,25 +104,21 @@ export class MoneyMarketRead extends BlockchainEntityRead {
       })
     );
     promises.push(
-      this._comptroller
+      this.env.comptroller
         .rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address, false)
         .then((res) => {
           rewardSpeed = new TokenAmount(PLYToken, res.toString());
         })
     );
     promises.push(
-      fetchPrice(
-        consts.networkAddresses.tokens.PLY,
-        this._networkConnection.provider
-      ).then((res) => {
-        plyPrice = res;
-      })
+      fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider).then(
+        (res) => {
+          plyPrice = res;
+        }
+      )
     );
     promises.push(
-      fetchPrice(
-        this.underlying.address,
-        this._networkConnection.provider
-      ).then((res) => {
+      fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {
         underlyingPrice = res;
       })
     );
@@ -191,25 +142,21 @@ export class MoneyMarketRead extends BlockchainEntityRead {
       })
     );
     promises.push(
-      this._comptroller
+      this.env.comptroller
         .rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address, true)
         .then((res) => {
           rewardSpeed = new TokenAmount(PLYToken, res.toString());
         })
     );
     promises.push(
-      fetchPrice(
-        consts.networkAddresses.tokens.PLY,
-        this._networkConnection.provider
-      ).then((res) => {
-        plyPrice = res;
-      })
+      fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider).then(
+        (res) => {
+          plyPrice = res;
+        }
+      )
     );
     promises.push(
-      fetchPrice(
-        this.underlying.address,
-        this._networkConnection.provider
-      ).then((res) => {
+      fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {
         underlyingPrice = res;
       })
     );
@@ -253,27 +200,21 @@ export class MoneyMarketRead extends BlockchainEntityRead {
       })
     );
 
-    var plyPrice: BigNumber,
-      underlyingPrice: BigNumber,
-      rewardSpeeds: RewardSpeeds;
+    var plyPrice: BigNumber, underlyingPrice: BigNumber, rewardSpeeds: RewardSpeeds;
     promises.push(
       this.getRewardSpeeds().then((res) => {
         rewardSpeeds = res;
       })
     );
     promises.push(
-      fetchPrice(
-        consts.networkAddresses.tokens.PLY,
-        this._networkConnection.provider
-      ).then((res) => {
-        plyPrice = res;
-      })
+      fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider).then(
+        (res) => {
+          plyPrice = res;
+        }
+      )
     );
     promises.push(
-      fetchPrice(
-        this.underlying.address,
-        this._networkConnection.provider
-      ).then((res) => {
+      fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {
         underlyingPrice = res;
       })
     );
@@ -282,10 +223,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 
     var borrowPlyApy = helpers.calcLMRewardApr(
       calcValuation(
-        new TokenAmount(
-          PLYToken,
-          rewardSpeeds!.plyRewardBorrowSpeed.toString()
-        ),
+        new TokenAmount(PLYToken, rewardSpeeds!.plyRewardBorrowSpeed.toString()),
         plyPrice!
       ),
       underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()),
@@ -293,10 +231,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     );
     var depositPlyApy = helpers.calcLMRewardApr(
       calcValuation(
-        new TokenAmount(
-          PLYToken,
-          rewardSpeeds!.plyRewardSupplySpeed.toString()
-        ),
+        new TokenAmount(PLYToken, rewardSpeeds!.plyRewardSupplySpeed.toString()),
         plyPrice!
       ),
       underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
@@ -304,28 +239,17 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     );
 
     var depositNEARApy = helpers.calcLMRewardApr(
-      await fetchValuation(
-        this.getDepositNEARRewardPerWeek(),
-        this._networkConnection.provider
-      ),
+      await fetchValuation(this.getDepositNEARRewardPerWeek(), this._networkConnection.provider),
       underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
       52
     );
     var borrowNEARApy = helpers.calcLMRewardApr(
-      await fetchValuation(
-        this.getBorrowNEARRewardPerWeek(),
-        this._networkConnection.provider
-      ),
+      await fetchValuation(this.getBorrowNEARRewardPerWeek(), this._networkConnection.provider),
       underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()),
       52
     );
     var depositMETAApy;
-    if (
-      helpers.isSameAddress(
-        this.underlying.address,
-        consts.networkAddresses.tokens.stNEAR
-      )
-    ) {
+    if (helpers.isSameAddress(this.underlying.address, consts.networkAddresses.tokens.stNEAR)) {
       depositMETAApy = helpers.calcLMRewardApr(
         new BigNumber(50000),
         underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
@@ -359,18 +283,12 @@ export class MoneyMarketRead extends BlockchainEntityRead {
   }
 
   public async getUserBorrowBalance(userAddress: string): Promise<TokenAmount> {
-    const totalBorrow: BN = await this.auToken.callStatic.borrowBalanceCurrent(
-      userAddress
-    );
+    const totalBorrow: BN = await this.auToken.callStatic.borrowBalanceCurrent(userAddress);
     return new TokenAmount(this.underlying, totalBorrow.toString());
   }
 
-  public async getUserDepositBalance(
-    userAddress: string
-  ): Promise<TokenAmount> {
-    const totalDeposit: BN = await this.auToken.callStatic.balanceOfUnderlying(
-      userAddress
-    );
+  public async getUserDepositBalance(userAddress: string): Promise<TokenAmount> {
+    const totalDeposit: BN = await this.auToken.callStatic.balanceOfUnderlying(userAddress);
     return new TokenAmount(this.underlying, totalDeposit.toString());
   }
 
@@ -384,9 +302,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     const currentTime = helpers.getCurrentTimestamp();
     if (currentTime <= rewardStopTime && currentTime > rewardStartTime) {
       const reward =
-        consts.DEPOSIT_NEAR_REWARDS_PER_WEEK[
-          this.underlying.address.toLocaleLowerCase()
-        ] ?? '0';
+        consts.DEPOSIT_NEAR_REWARDS_PER_WEEK[this.underlying.address.toLocaleLowerCase()] ?? '0';
       return new TokenAmount(NEARToken, reward, false);
     } else {
       return new TokenAmount(NEARToken, '0');
@@ -403,9 +319,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     const currentTime = helpers.getCurrentTimestamp();
     if (currentTime <= rewardStopTime && currentTime > rewardStartTime) {
       const reward =
-        consts.BORROW_NEAR_REWARDS_PER_WEEK[
-          this.underlying.address.toLocaleLowerCase()
-        ] ?? '0';
+        consts.BORROW_NEAR_REWARDS_PER_WEEK[this.underlying.address.toLocaleLowerCase()] ?? '0';
       return new TokenAmount(NEARToken, reward, false);
     } else {
       return new TokenAmount(NEARToken, '0');
@@ -415,15 +329,11 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 
 export class MoneyMarketReadWrite extends MoneyMarketRead {
   protected _EthRepayHelper: EthRepayHelper;
-  constructor(
-    networkConnection: NetworkConnection,
-    auToken: Address,
-    underlyingAsset: Address
-  ) {
+  constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
     super(networkConnection, auToken, underlyingAsset);
     this._EthRepayHelper = new Contract(
       consts.networkAddresses.misc.ETHREPAYHELPER,
-      EthRepayHelperABI.abi,
+      abis.EthRepayHelperABI.abi,
       networkConnection.provider
     ) as EthRepayHelper;
   }
@@ -440,15 +350,11 @@ export class MoneyMarketReadWrite extends MoneyMarketRead {
     }
   }
   public async borrow(amount: TokenAmount): Promise<TransactionResponse> {
-    return this.auToken
-      .connect(this._networkConnection.signer!)
-      .borrow(amount.rawAmount());
+    return this.auToken.connect(this._networkConnection.signer!).borrow(amount.rawAmount());
   }
   public async withdraw(amount: TokenAmount): Promise<TransactionResponse> {
     if (new BigNumber(amount.rawAmount()).lt(0)) {
-      return this.auToken
-        .connect(this._networkConnection.signer!)
-        .redeemUnderlying(consts.INF);
+      return this.auToken.connect(this._networkConnection.signer!).redeemUnderlying(consts.INF);
     }
     return this.auToken
       .connect(this._networkConnection.signer!)
@@ -461,9 +367,7 @@ export class MoneyMarketReadWrite extends MoneyMarketRead {
         .repayBorrow({ value: amount.rawAmount() });
     } else {
       if (new BigNumber(amount.rawAmount()).lt(0)) {
-        return this.auToken
-          .connect(this._networkConnection.signer!)
-          .repayBorrow(consts.INF);
+        return this.auToken.connect(this._networkConnection.signer!).repayBorrow(consts.INF);
       } else {
         return this.auToken
           .connect(this._networkConnection.signer!)
@@ -472,12 +376,12 @@ export class MoneyMarketReadWrite extends MoneyMarketRead {
     }
   }
   public async enableCollateral(): Promise<TransactionResponse> {
-    return this._comptroller
+    return this.env.comptroller
       .connect(this._networkConnection.signer!)
       .enterMarkets([this.auToken.address]);
   }
   public async disableCollateral(): Promise<TransactionResponse> {
-    return this._comptroller
+    return this.env.comptroller
       .connect(this._networkConnection.signer!)
       .exitMarket(this.auToken.address);
   }
@@ -493,18 +397,10 @@ export class MoneyMarket extends BlockchainEntity {
     this.underlying = helpers.validateAndParseAddress(underlying);
   }
   public read(networkConnection: NetworkConnection): MoneyMarketRead {
-    return new MoneyMarketRead(
-      networkConnection,
-      this.address,
-      this.underlying
-    );
+    return new MoneyMarketRead(networkConnection, this.address, this.underlying);
   }
 
   public readWrite(networkConnection: NetworkConnection): MoneyMarketReadWrite {
-    return new MoneyMarketReadWrite(
-      networkConnection,
-      this.address,
-      this.underlying
-    );
+    return new MoneyMarketReadWrite(networkConnection, this.address, this.underlying);
   }
 }

package/src/contracts/Multicall.ts

@@ -1,10 +1,10 @@
-import Multicall2ABI from '@aurigami/contracts/artifacts/contracts/mock/Multicall2.sol/Multicall2.json';
 import { Multicall2 } from '@aurigami/contracts/typechain';
 import { Contract, ethers } from 'ethers';
+import { Result } from 'ethers/lib/utils';
+import * as abis from '../abis';
 import * as consts from '../consts';
 import { BlockchainEntityRead } from '../entities';
 import { NetworkConnection } from '../types';
-import { Result } from 'ethers/lib/utils';
 
 export class MulticallRead extends BlockchainEntityRead {
   protected _multicall: Multicall2;
@@ -12,7 +12,7 @@ export class MulticallRead extends BlockchainEntityRead {
     super(networkConnection);
     this._multicall = new Contract(
       consts.networkAddresses.misc.MULTICALL,
-      Multicall2ABI.abi,
+      abis.Multicall2ABI.abi,
       networkConnection.provider
     ) as Multicall2;
   }
@@ -32,9 +32,7 @@ export class MulticallRead extends BlockchainEntityRead {
     // prepare transactions
     for (let i = 0; i < calls.length; i++) {
       const call = calls[i];
-      let txn = await call.contract.populateTransaction[call.method](
-        ...call.args
-      );
+      let txn = await call.contract.populateTransaction[call.method](...call.args);
       txns.push({ target: txn.to!, callData: txn.data! });
     }
 
@@ -44,10 +42,7 @@ export class MulticallRead extends BlockchainEntityRead {
     const decodedReturn = [];
     for (let i = 0; i < calls.length; i++) {
       decodedReturn.push(
-        ethers.utils.defaultAbiCoder.decode(
-          calls[i].returnTypes,
-          response.returnData[i]
-        )
+        ethers.utils.defaultAbiCoder.decode(calls[i].returnTypes, response.returnData[i])
       );
     }
     return decodedReturn;

package/src/contracts/Papermill.ts

@@ -1,25 +1,8 @@
-import AuriFairLaunchABI from '@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json';
-import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
-import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
-import EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
-import PulpABI from '@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json';
-import {
-  AuriFairLaunch,
-  AuriLens,
-  Comptroller,
-  IERC20,
-  PULP,
-} from '@aurigami/contracts/typechain';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract } from 'ethers';
+import { BigNumber as BN } from 'ethers';
 import * as consts from '../consts';
-import {
-  BlockchainEntity,
-  BlockchainEntityRead,
-  Token,
-  TokenAmount,
-} from '../entities';
+import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from '../entities';
 import * as helpers from '../helpers';
 import { Address, NetworkConnection, UserLockingDetails } from '../types';
 
@@ -27,76 +10,41 @@ const LOCKING_DENOMINATOR = BN.from(10000);
 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;
+  protected env: AuriEnv;
 
   constructor(networkConnection: NetworkConnection) {
     super(networkConnection);
+    this.env = new AuriEnv(networkConnection);
 
     let plyAddress = consts.networkAddresses.tokens.PLY;
     let pulpAddress = consts.networkAddresses.tokens.PULP;
 
     this.plyToken = new Token(plyAddress, helpers.getDecimal(plyAddress));
     this.pulpToken = new Token(pulpAddress, helpers.getDecimal(pulpAddress));
-
-    this._comptroller = new Contract(
-      consts.networkAddresses.misc.COMPTROLLER,
-      ComptrollerABI.abi,
-      networkConnection.provider
-    ) as Comptroller;
-    this._auriFairLaunch = new Contract(
-      consts.networkAddresses.misc.AURIFAIRLAUNCH,
-      AuriFairLaunchABI.abi,
-      networkConnection.provider
-    ) as AuriFairLaunch;
-    this._auriLens = new Contract(
-      consts.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);
+    const plyBalance = await this.env.ply.balanceOf(userAddress);
     return new TokenAmount(this.plyToken, plyBalance.toString());
   }
 
   public async getPulpBalance(userAddress: Address): Promise<TokenAmount> {
-    const pulpBalance = await this._pulp.balanceOf(userAddress);
+    const pulpBalance = await this.env.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,
+  public async getUnclaimedPlyReward(userAddress: Address): Promise<TokenAmount> {
+    let rewardBalancesMetadata = await this.env.auriLens.callStatic.claimRewards(
+      this.env.comptroller.address,
+      this.env.auriFairLaunch.address,
       consts.ALL_STAKING_POOLS,
       { from: userAddress }
     );
 
-    return new TokenAmount(
-      this.plyToken,
-      rewardBalancesMetadata.plyAccrured.toString()
-    );
+    return new TokenAmount(this.plyToken, rewardBalancesMetadata.plyAccrured.toString());
   }
 
   private getWeek(timestamp: number): number {
@@ -108,25 +56,15 @@ export class PapermillRead extends BlockchainEntityRead {
   /**
    * Get all locking details of the user in all markets + all staking pools
    */
-  public async getLockingDetails(
-    userAddress: Address
-  ): Promise<UserLockingDetails> {
+  public async getLockingDetails(userAddress: Address): Promise<UserLockingDetails> {
     const currentWeek = this.getWeek(helpers.getCurrentTimestamp());
     var promises: any[] = [];
 
     promises.push(
-      this._auriLens.getPercentLock(
-        this._pulp.address,
-        userAddress,
-        currentWeek
-      )
+      this.env.auriLens.getPercentLock(this.env.pulp.address, userAddress, currentWeek)
     );
     promises.push(
-      this._auriLens.getPercentLock(
-        this._pulp.address,
-        userAddress,
-        currentWeek + 1
-      )
+      this.env.auriLens.getPercentLock(this.env.pulp.address, userAddress, currentWeek + 1)
     );
     promises.push(this.getUnclaimedPlyReward(userAddress));
 
@@ -136,44 +74,31 @@ export class PapermillRead extends BlockchainEntityRead {
     let percentLockNextWeek = BN.from(values[1]);
     let totalRewards = values[2] as TokenAmount;
 
-    let [pulpAmountCurrentWeek, plyAmountCurrentWeek] =
-      await this._pulp.calcLockAmount(userAddress, totalRewards.rawAmount());
+    let [pulpAmountCurrentWeek, plyAmountCurrentWeek] = await this.env.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(LOCKING_DENOMINATOR);
-    let pulpAmountNextWeek = BN.from(totalRewards.rawAmount()).sub(
-      plyAmountNextWeek
-    );
+    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 = LOCKING_DENOMINATOR.sub(
-      percentLockCurrentWeek
-    ).toString();
-    let nextUnlockPortion =
-      LOCKING_DENOMINATOR.sub(percentLockNextWeek).toString();
+    let currentUnlockPortion = LOCKING_DENOMINATOR.sub(percentLockCurrentWeek).toString();
+    let nextUnlockPortion = LOCKING_DENOMINATOR.sub(percentLockNextWeek).toString();
 
     return {
       vestingStart: consts.REWARD_CLAIM_START,
-      currentUnlockPortion: new BigNumber(currentUnlockPortion)
-        .dividedBy(100)
-        .toNumber(),
+      currentUnlockPortion: new BigNumber(currentUnlockPortion).dividedBy(100).toNumber(),
       accruedPly: totalRewards,
-      currentPly: new TokenAmount(
-        this.plyToken,
-        plyAmountCurrentWeek.toString()
-      ),
-      currentPulp: new TokenAmount(
-        this.pulpToken,
-        pulpAmountCurrentWeek.toString()
-      ),
+      currentPly: new TokenAmount(this.plyToken, plyAmountCurrentWeek.toString()),
+      currentPulp: new TokenAmount(this.pulpToken, pulpAmountCurrentWeek.toString()),
       //
-      nextUnlockPortion: new BigNumber(nextUnlockPortion)
-        .dividedBy(100)
-        .toNumber(),
+      nextUnlockPortion: new BigNumber(nextUnlockPortion).dividedBy(100).toNumber(),
       nextPly: new TokenAmount(this.plyToken, plyAmountNextWeek.toString()),
       nextPulp: new TokenAmount(this.pulpToken, pulpAmountNextWeek.toString()),
     };
@@ -189,8 +114,8 @@ export class PapermillRead extends BlockchainEntityRead {
     userAddress: Address,
     targetUnlockPortion: number
   ): Promise<number> {
-    let weekId = await this._auriLens.getWeekToUnlock(
-      this._pulp.address,
+    let weekId = await this.env.auriLens.getWeekToUnlock(
+      this.env.pulp.address,
       userAddress,
       targetUnlockPortion * 100
     );
@@ -210,12 +135,9 @@ export class PapermillRead extends BlockchainEntityRead {
     return consts.REWARD_CLAIM_START + consts.ONE_WEEK * nextWeek;
   }
 
-  public async getUnlockPortionAt(
-    userAddress: Address,
-    timestamp: number
-  ): Promise<number> {
-    let lockPortion = await this._auriLens.getPercentLock(
-      this._pulp.address,
+  public async getUnlockPortionAt(userAddress: Address, timestamp: number): Promise<number> {
+    let lockPortion = await this.env.auriLens.getPercentLock(
+      this.env.pulp.address,
       userAddress,
       this.getWeek(timestamp)
     );
@@ -237,11 +159,8 @@ export class PapermillReadWrite extends PapermillRead {
    * @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
+  public async redeem(recipient: Address, amount: TokenAmount): Promise<TransactionResponse> {
+    return this.env.pulp
       .connect(this._networkConnection.signer!)
       .redeem(recipient, amount.rawAmount());
   }