@gooddollar/goodprotocol 2.0.13 → 2.0.14-beta.0

package/test/staking/StakingRewards.test.ts

@@ -3,13 +3,7 @@ import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 import { GoodMarketMaker } from "../../types";
-import {
-  createDAO,
-  increaseTime,
-  advanceBlocks,
-  deployUniswap,
-  getStakingFactory
-} from "../helpers";
+import { createDAO, increaseTime, advanceBlocks, deployUniswap, getStakingFactory } from "../helpers";
 import ContributionCalculation from "@gooddollar/goodcontracts/stakingModel/build/contracts/ContributionCalculation.json";
 import IUniswapV2Pair from "@uniswap/v2-core/build/IUniswapV2Pair.json";
 const BN = ethers.BigNumber;
@@ -72,15 +66,9 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     const cdaiFactory = await ethers.getContractFactory("cDAIMock");
     const cBatFactory = await ethers.getContractFactory("cBATMock");
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    goodCompoundStakingFactory = await getStakingFactory(
-      "GoodCompoundStakingV2"
-    );
-    goodCompoundStakingTestFactory = await getStakingFactory(
-      "GoodCompoundStakingTest"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+    goodCompoundStakingFactory = await getStakingFactory("GoodCompoundStakingV2");
+    goodCompoundStakingTestFactory = await getStakingFactory("GoodCompoundStakingTest");
 
     const daiFactory = await ethers.getContractFactory("DAIMock");
 
@@ -105,13 +93,9 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       controller,
       avatar
     });
-    goodFundManager = await upgrades.deployProxy(
-      goodFundManagerFactory,
-      [nameService.address],
-      {
-        kind: "uups"
-      }
-    );
+    goodFundManager = await upgrades.deployProxy(goodFundManagerFactory, [nameService.address], {
+      kind: "uups"
+    });
     await setDAOAddress("FUND_MANAGER", goodFundManager.address);
     console.log("Deployed goodfund manager", {
       manager: goodFundManager.address
@@ -129,15 +113,11 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     });
 
     console.log("setting permissions...");
-    const tokenUsdOracleFactory = await ethers.getContractFactory(
-      "BatUSDMockOracle"
-    );
+    const tokenUsdOracleFactory = await ethers.getContractFactory("BatUSDMockOracle");
     await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
 
     daiUsdOracle = await tokenUsdOracleFactory.deploy();
-    const compUsdOracleFactory = await ethers.getContractFactory(
-      "CompUSDMockOracle"
-    );
+    const compUsdOracleFactory = await ethers.getContractFactory("CompUSDMockOracle");
     compUsdOracle = await compUsdOracleFactory.deploy();
 
     deployStaking = (token, itoken, blocksThreashold = "50") =>
@@ -161,13 +141,9 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     console.log("initializing marketmaker...");
 
     cDAI1 = await cdaiFactory.deploy(dai.address);
-    const cdaiLowWorthFactory = await ethers.getContractFactory(
-      "cDAILowWorthMock"
-    );
+    const cdaiLowWorthFactory = await ethers.getContractFactory("cDAILowWorthMock");
     cDAI2 = await cdaiLowWorthFactory.deploy(dai.address);
-    const cdaiNonMintableFactory = await ethers.getContractFactory(
-      "cDAINonMintableMock"
-    );
+    const cdaiNonMintableFactory = await ethers.getContractFactory("cDAINonMintableMock");
     cDAI3 = await cdaiNonMintableFactory.deploy(dai.address);
     bat = await daiFactory.deploy(); // Another erc20 token for uniswap router test
     cBat = await cBatFactory.deploy(bat.address);
@@ -192,82 +168,45 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     await factory.createPair(bat.address, dai.address); // Create tokenA and dai pair
     const pairAddress = factory.getPair(bat.address, dai.address);
-    pair = new Contract(
-      pairAddress,
-      JSON.stringify(IUniswapV2Pair.abi),
-      staker
-    ).connect(founder);
+    pair = new Contract(pairAddress, JSON.stringify(IUniswapV2Pair.abi), staker).connect(founder);
     await setDAOAddress("CDAI", cDAI.address);
     await setDAOAddress("DAI", dai.address);
 
     batUsdOracle = await tokenUsdOracleFactory.deploy();
 
-    await dai["mint(address,uint256)"](
-      founder.address,
-      ethers.utils.parseEther("2000000")
-    );
-    await bat["mint(address,uint256)"](
-      founder.address,
-      ethers.utils.parseEther("2000000")
-    );
+    await dai["mint(address,uint256)"](founder.address, ethers.utils.parseEther("2000000"));
+    await bat["mint(address,uint256)"](founder.address, ethers.utils.parseEther("2000000"));
 
-    await addLiquidity(
-      ethers.utils.parseEther("2000000"),
-      ethers.utils.parseEther("2000000")
-    );
+    await addLiquidity(ethers.utils.parseEther("2000000"), ethers.utils.parseEther("2000000"));
 
-    gasFeeOracle = await ethers.getContractAt(
-      "GasPriceMockOracle",
-      await nameService.getAddress("GAS_PRICE_ORACLE")
-    );
-    daiEthOracle = await ethers.getContractAt(
-      "DaiEthPriceMockOracle",
-      await nameService.getAddress("DAI_ETH_ORACLE")
-    );
+    gasFeeOracle = await ethers.getContractAt("GasPriceMockOracle", await nameService.getAddress("GAS_PRICE_ORACLE"));
+    daiEthOracle = await ethers.getContractAt("DaiEthPriceMockOracle", await nameService.getAddress("DAI_ETH_ORACLE"));
     await setDAOAddress("MARKET_MAKER", marketMaker.address);
   });
 
   it("should be set rewards per block for particular stacking contract", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     const encodedData = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        goodCompoundStaking.address,
-        currentBlockNumber - 5,
-        currentBlockNumber + 10,
-        false
-      ] // set 10 gd per block
+      ["1000", goodCompoundStaking.address, currentBlockNumber - 5, currentBlockNumber + 10, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
-    let rewardPerBlock = await goodFundManager.rewardsForStakingContract(
-      goodCompoundStaking.address
-    );
+    let rewardPerBlock = await goodFundManager.rewardsForStakingContract(goodCompoundStaking.address);
     expect(rewardPerBlock[0].toString()).to.be.equal("1000");
-    expect(rewardPerBlock[1].toString()).to.be.equal(
-      (currentBlockNumber - 5).toString()
-    );
-    expect(rewardPerBlock[2].toString()).to.be.equal(
-      (currentBlockNumber + 10).toString()
-    );
+    expect(rewardPerBlock[1].toString()).to.be.equal((currentBlockNumber - 5).toString());
+    expect(rewardPerBlock[2].toString()).to.be.equal((currentBlockNumber + 10).toString());
     expect(rewardPerBlock[3]).to.be.equal(false);
   });
 
   it("should be able to earn rewards after some block passed", async () => {
     let stakingAmount = ethers.utils.parseEther("100");
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
     let gdBalanceBeforeWithdraw = await goodDollar.balanceOf(staker.address);
     await advanceBlocks(4);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
     let gdBalancerAfterWithdraw = await goodDollar.balanceOf(staker.address);
     expect(gdBalancerAfterWithdraw.toString()).to.be.equal("2500");
   });
@@ -276,142 +215,78 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount.mul(BN.from("2")));
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount.mul(BN.from("2")));
 
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
-    const userStakeInfoBeforeWithdraw = await goodCompoundStaking.users(
-      staker.address
-    );
-    expect(userStakeInfoBeforeWithdraw.effectiveStakes).to.be.equal(
-      stakingAmount
-    );
-    expect(userStakeInfoBeforeWithdraw.amount).to.be.equal(
-      stakingAmount.mul(BN.from("2"))
-    );
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
-    const userStakeInfoAfterWithdraw = await goodCompoundStaking.users(
-      staker.address
-    );
-    expect(userStakeInfoAfterWithdraw.effectiveStakes).to.be.equal(
-      stakingAmount.div(BN.from("2"))
-    ); // should be half of the stakes that staked initially
+    const userStakeInfoBeforeWithdraw = await goodCompoundStaking.users(staker.address);
+    expect(userStakeInfoBeforeWithdraw.effectiveStakes).to.be.equal(stakingAmount);
+    expect(userStakeInfoBeforeWithdraw.amount).to.be.equal(stakingAmount.mul(BN.from("2")));
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
+    const userStakeInfoAfterWithdraw = await goodCompoundStaking.users(staker.address);
+    expect(userStakeInfoAfterWithdraw.effectiveStakes).to.be.equal(stakingAmount.div(BN.from("2"))); // should be half of the stakes that staked initially
     expect(userStakeInfoAfterWithdraw.amount).to.be.equal(stakingAmount);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
   });
   it("it should not increase totalEffectiveStakes when staked amount's rewards are donated", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
-    const totalEffectiveStakesBeforeStake = await goodCompoundStaking
-      .getStats()
-      .then(_ => _[3]);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
+    const totalEffectiveStakesBeforeStake = await goodCompoundStaking.getStats().then(_ => _[3]);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
-    const totalEffectiveStakesAfterStake = await goodCompoundStaking
-      .getStats()
-      .then(_ => _[3]);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
-    expect(totalEffectiveStakesAfterStake).to.be.equal(
-      totalEffectiveStakesBeforeStake
-    );
+    const totalEffectiveStakesAfterStake = await goodCompoundStaking.getStats().then(_ => _[3]);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
+    expect(totalEffectiveStakesAfterStake).to.be.equal(totalEffectiveStakesBeforeStake);
   });
   it("it should increase totalEffectiveStakes when staked without donation", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
-    const totalEffectiveStakesBeforeStake = await goodCompoundStaking
-      .getStats()
-      .then(_ => _[3]);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
+    const totalEffectiveStakesBeforeStake = await goodCompoundStaking.getStats().then(_ => _[3]);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
-    const totalEffectiveStakesAfterStake = await goodCompoundStaking
-      .getStats()
-      .then(_ => _[3]);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
-    expect(totalEffectiveStakesAfterStake).to.be.gt(
-      totalEffectiveStakesBeforeStake
-    );
+    const totalEffectiveStakesAfterStake = await goodCompoundStaking.getStats().then(_ => _[3]);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
+    expect(totalEffectiveStakesAfterStake).to.be.gt(totalEffectiveStakesBeforeStake);
   });
   it("it should withdraw effective and stakes according to ratio", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
 
-    await goodCompoundStaking
-      .connect(staker)
-      .stake(stakingAmount.mul(80).div(100), 0, false);
-    await goodCompoundStaking
-      .connect(staker)
-      .stake(stakingAmount.mul(20).div(100), 100, false);
-    const userStakeInfoBeforeWithdraw = await goodCompoundStaking.users(
-      staker.address
-    );
+    await goodCompoundStaking.connect(staker).stake(stakingAmount.mul(80).div(100), 0, false);
+    await goodCompoundStaking.connect(staker).stake(stakingAmount.mul(20).div(100), 100, false);
+    const userStakeInfoBeforeWithdraw = await goodCompoundStaking.users(staker.address);
     const withdrawAmount = stakingAmount.mul(20).div(100);
     const withdrawFromEffectiveStake = withdrawAmount
       .mul(userStakeInfoBeforeWithdraw.effectiveStakes)
       .div(userStakeInfoBeforeWithdraw.amount);
     const withdrawFromDonation = withdrawAmount.sub(withdrawFromEffectiveStake);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(withdrawAmount, false);
-    const userStakeInfoAfterWithdraw = await goodCompoundStaking.users(
-      staker.address
-    );
+    await goodCompoundStaking.connect(staker).withdrawStake(withdrawAmount, false);
+    const userStakeInfoAfterWithdraw = await goodCompoundStaking.users(staker.address);
     expect(userStakeInfoBeforeWithdraw.effectiveStakes).to.be.gt(0);
     expect(userStakeInfoAfterWithdraw.effectiveStakes).to.be.equal(
-      userStakeInfoBeforeWithdraw.effectiveStakes.sub(
-        withdrawFromEffectiveStake
-      )
+      userStakeInfoBeforeWithdraw.effectiveStakes.sub(withdrawFromEffectiveStake)
     );
-    expect(
-      userStakeInfoAfterWithdraw.amount.sub(
-        userStakeInfoAfterWithdraw.effectiveStakes
-      )
-    ).to.be.equal(
-      userStakeInfoBeforeWithdraw.amount
-        .sub(userStakeInfoBeforeWithdraw.effectiveStakes)
-        .sub(withdrawFromDonation)
+    expect(userStakeInfoAfterWithdraw.amount.sub(userStakeInfoAfterWithdraw.effectiveStakes)).to.be.equal(
+      userStakeInfoBeforeWithdraw.amount.sub(userStakeInfoBeforeWithdraw.effectiveStakes).sub(withdrawFromDonation)
     );
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount.sub(withdrawAmount), false); // withdraw left amount
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount.sub(withdrawAmount), false); // withdraw left amount
   });
   it("shouldn't be able to earn rewards after rewards blockend passed", async () => {
     let stakingAmount = ethers.utils.parseEther("100");
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
 
     let gdBalanceBeforeWithdraw = await goodDollar.balanceOf(staker.address);
     advanceBlocks(5);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
     let gdBalancerAfterWithdraw = await goodDollar.balanceOf(staker.address);
 
-    expect(gdBalancerAfterWithdraw.toString()).to.be.equal(
-      gdBalanceBeforeWithdraw.toString()
-    );
+    expect(gdBalancerAfterWithdraw.toString()).to.be.equal(gdBalanceBeforeWithdraw.toString());
   });
 
   it("shouldn't be able to mint reward when staking contract is blacklisted", async () => {
@@ -425,9 +300,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     let stakingAmount = ethers.utils.parseEther("100");
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking2.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking2.address, stakingAmount);
     await goodCompoundStaking2.connect(staker).stake(stakingAmount, 0, false);
 
     let gdBalanceBeforeWithdraw = await goodDollar.balanceOf(staker.address);
@@ -439,9 +312,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     );
     await genericCall(goodFundManager.address, encodedDataTwo);
 
-    await goodCompoundStaking2
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking2.connect(staker).withdrawStake(stakingAmount, false);
     let gdBalancerAfterWithdraw = await goodDollar.balanceOf(staker.address);
 
     expect(gdBalancerAfterWithdraw).to.be.equal(gdBalanceBeforeWithdraw);
@@ -488,34 +359,20 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
   it("it should send staker's productivity to some other user", async () => {
     let stakingAmount = ethers.utils.parseEther("100");
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
-    let stakersProductivityBefore = await goodCompoundStaking.getProductivity(
-      staker.address
-    );
-    await goodCompoundStaking
-      .connect(staker)
-      .transfer(founder.address, stakingAmount);
-    let stakersProductivityAfter = await goodCompoundStaking
-      .connect(staker)
-      .getProductivity(staker.address);
-    let foundersProductivity = await goodCompoundStaking.getProductivity(
-      founder.address
-    );
+    let stakersProductivityBefore = await goodCompoundStaking.getProductivity(staker.address);
+    await goodCompoundStaking.connect(staker).transfer(founder.address, stakingAmount);
+    let stakersProductivityAfter = await goodCompoundStaking.connect(staker).getProductivity(staker.address);
+    let foundersProductivity = await goodCompoundStaking.getProductivity(founder.address);
 
     expect(stakersProductivityAfter[0].toString()).to.be.equal("0");
-    expect(foundersProductivity[0].toString()).to.be.equals(
-      stakingAmount.toString()
-    );
+    expect(foundersProductivity[0].toString()).to.be.equals(stakingAmount.toString());
   });
 
   it("it shouldn't be able to withdraw stake when staker sent it to another user", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
-    await expect(
-      goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false)
-    ).to.be.reverted;
+    await expect(goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false)).to.be.reverted;
   });
 
   it("it should be able to withdraw their stake when got staking tokens from somebody else", async () => {
@@ -523,9 +380,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     await goodCompoundStaking.withdrawStake(stakingAmount, false);
 
-    const foundersProductivity = await goodCompoundStaking.getProductivity(
-      founder.address
-    );
+    const foundersProductivity = await goodCompoundStaking.getProductivity(founder.address);
     expect(foundersProductivity[0].toString()).to.be.equal("0");
     expect(foundersProductivity[1].toString()).to.be.equal("0"); // Total productivity also should equal 0
   });
@@ -534,73 +389,43 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
 
-    await dai["mint(address,uint256)"](
-      staker.address,
-      ethers.utils.parseEther("1000000")
-    );
-    await dai
-      .connect(staker)
-      .transfer(cDAI.address, ethers.utils.parseEther("1000000")); // We should put extra DAI to mock cDAI contract in order to provide interest
+    await dai["mint(address,uint256)"](staker.address, ethers.utils.parseEther("1000000"));
+    await dai.connect(staker).transfer(cDAI.address, ethers.utils.parseEther("1000000")); // We should put extra DAI to mock cDAI contract in order to provide interest
     await cDAI.increasePriceWithMultiplier("1500"); // increase interest by calling exchangeRateCurrent
 
-    const currentUBIInterestBeforeWithdraw =
-      await goodCompoundStaking.currentGains(false, true);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
-    const gdBalanceBeforeCollectInterest = await goodDollar.balanceOf(
-      staker.address
-    );
-    const contractAddressesToBeCollected =
-      await goodFundManager.calcSortedContracts();
+    const currentUBIInterestBeforeWithdraw = await goodCompoundStaking.currentGains(false, true);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
+    const gdBalanceBeforeCollectInterest = await goodDollar.balanceOf(staker.address);
+    const contractAddressesToBeCollected = await goodFundManager.calcSortedContracts();
     const addressesToCollect = contractAddressesToBeCollected.map(x => x[0]);
-    await goodFundManager
-      .connect(staker)
-      .collectInterest(addressesToCollect, false);
-    const gdBalanceAfterCollectInterest = await goodDollar.balanceOf(
-      staker.address
-    );
-    const currentUBIInterestAfterWithdraw =
-      await goodCompoundStaking.currentGains(false, true);
+    await goodFundManager.connect(staker).collectInterest(addressesToCollect, false);
+    const gdBalanceAfterCollectInterest = await goodDollar.balanceOf(staker.address);
+    const currentUBIInterestAfterWithdraw = await goodCompoundStaking.currentGains(false, true);
     expect(currentUBIInterestBeforeWithdraw[0].toString()).to.not.be.equal("0");
     expect(currentUBIInterestAfterWithdraw[0].toString()).to.be.equal("0");
     expect(gdBalanceAfterCollectInterest.gt(gdBalanceBeforeCollectInterest));
   });
 
   it("it should get rewards with updated values", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     const encodedDataTwo = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        goodCompoundStaking.address,
-        currentBlockNumber,
-        currentBlockNumber + 5000,
-        false
-      ] // set 10 gd per block
+      ["1000", goodCompoundStaking.address, currentBlockNumber, currentBlockNumber + 5000, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedDataTwo, avatar, 0);
 
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
 
     await advanceBlocks(4);
-    const stakingContractVals = await goodFundManager.rewardsForStakingContract(
-      goodCompoundStaking.address
-    );
+    const stakingContractVals = await goodFundManager.rewardsForStakingContract(goodCompoundStaking.address);
     let rewardsEarned = await goodCompoundStaking.getUserPendingReward(
       staker.address,
       stakingContractVals[0],
@@ -608,71 +433,46 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       stakingContractVals[2]
     );
     //baseshare rewards is in 18 decimals
-    expect(rewardsEarned.toString()).to.be.equal(
-      ethers.utils.parseUnits("20", 18)
-    ); // Each block reward is 10gd so total reward 40gd but since multiplier is 0.5 for first month should get 20gd
+    expect(rewardsEarned.toString()).to.be.equal(ethers.utils.parseUnits("20", 18)); // Each block reward is 10gd so total reward 40gd but since multiplier is 0.5 for first month should get 20gd
 
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
   });
 
   it("should get user minted and pending rewards", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     const encodedData = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        goodCompoundStaking.address,
-        currentBlockNumber,
-        currentBlockNumber + 5000,
-        false
-      ] // set 10 gd per block
+      ["1000", goodCompoundStaking.address, currentBlockNumber, currentBlockNumber + 5000, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
 
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
 
     await advanceBlocks(4);
 
-    const userMintedAndPending =
-      await goodCompoundStaking.getUserMintedAndPending(staker.address);
+    const userMintedAndPending = await goodCompoundStaking.getUserMintedAndPending(staker.address);
     const userMintedReward = userMintedAndPending[0].toString();
     const userPendingReward = userMintedAndPending[1].toString();
     expect(userMintedReward).to.equal("5000");
     expect(userPendingReward).to.equal("2000");
 
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
   });
 
   it("it should get rewards with 1x multiplier for after threshold pass", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
 
     const simpleStaking = await await deployStaking();
 
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     let encodedDataTwo = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        simpleStaking.address,
-        currentBlockNumber,
-        currentBlockNumber + 100,
-        false
-      ] // set 10 gd per block
+      ["1000", simpleStaking.address, currentBlockNumber, currentBlockNumber + 100, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedDataTwo, avatar, 0);
 
@@ -680,29 +480,17 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
     await dai.connect(staker).approve(simpleStaking.address, stakingAmount);
-    let gdBalanceStakerBeforeWithdraw = await goodDollar.balanceOf(
-      staker.address
-    );
+    let gdBalanceStakerBeforeWithdraw = await goodDollar.balanceOf(staker.address);
     await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
 
     await advanceBlocks(54);
     await simpleStaking.connect(staker).withdrawStake(stakingAmount, false);
-    let gdBalanceStakerAfterWithdraw = await goodDollar.balanceOf(
-      staker.address
-    );
+    let gdBalanceStakerAfterWithdraw = await goodDollar.balanceOf(staker.address);
 
-    expect(
-      gdBalanceStakerAfterWithdraw.sub(gdBalanceStakerBeforeWithdraw).toString()
-    ).to.be.equal("30000"); // 50 blocks reward worth 500gd but since it's with the 0.5x multiplier so 250gd then there is 5 blocks which gets full reward so total reward is 300gd
+    expect(gdBalanceStakerAfterWithdraw.sub(gdBalanceStakerBeforeWithdraw).toString()).to.be.equal("30000"); // 50 blocks reward worth 500gd but since it's with the 0.5x multiplier so 250gd then there is 5 blocks which gets full reward so total reward is 300gd
     encodedDataTwo = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        simpleStaking.address,
-        currentBlockNumber,
-        currentBlockNumber + 100,
-        true
-      ] // set 10 gd per block
+      ["1000", simpleStaking.address, currentBlockNumber, currentBlockNumber + 100, true] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedDataTwo, avatar, 0);
   });
@@ -711,27 +499,15 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
 
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
-    await goodCompoundStaking
-      .connect(staker)
-      .approve(founder.address, stakingAmount);
-    const stakingTokenBalanceBeforeTransfer =
-      await goodCompoundStaking.balanceOf(founder.address);
-    await goodCompoundStaking.transferFrom(
-      staker.address,
-      founder.address,
-      stakingAmount
-    );
-    const stakingTokenBalanceAfterTransfer =
-      await goodCompoundStaking.balanceOf(founder.address);
+    await goodCompoundStaking.connect(staker).approve(founder.address, stakingAmount);
+    const stakingTokenBalanceBeforeTransfer = await goodCompoundStaking.balanceOf(founder.address);
+    await goodCompoundStaking.transferFrom(staker.address, founder.address, stakingAmount);
+    const stakingTokenBalanceAfterTransfer = await goodCompoundStaking.balanceOf(founder.address);
 
-    expect(
-      stakingTokenBalanceAfterTransfer.gt(stakingTokenBalanceBeforeTransfer)
-    ).to.be.true;
+    expect(stakingTokenBalanceAfterTransfer.gt(stakingTokenBalanceBeforeTransfer)).to.be.true;
     await goodCompoundStaking.withdrawStake(stakingAmount, false);
   });
 
@@ -739,37 +515,28 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
 
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
     await advanceBlocks(5);
-    const stakingContractVals = await goodFundManager.rewardsForStakingContract(
-      goodCompoundStaking.address
+    const stakingContractVals = await goodFundManager.rewardsForStakingContract(goodCompoundStaking.address);
+    const earnedRewardBeforeWithdrawReward = await goodCompoundStaking.getUserPendingReward(
+      staker.address,
+      stakingContractVals[0],
+      stakingContractVals[1],
+      stakingContractVals[2]
     );
-    const earnedRewardBeforeWithdrawReward =
-      await goodCompoundStaking.getUserPendingReward(
-        staker.address,
-        stakingContractVals[0],
-        stakingContractVals[1],
-        stakingContractVals[2]
-      );
     await goodCompoundStaking.connect(staker).withdrawRewards();
-    const earnedRewardAfterWithdrawReward =
-      await goodCompoundStaking.getUserPendingReward(
-        staker.address,
-        stakingContractVals[0],
-        stakingContractVals[1],
-        stakingContractVals[2]
-      );
+    const earnedRewardAfterWithdrawReward = await goodCompoundStaking.getUserPendingReward(
+      staker.address,
+      stakingContractVals[0],
+      stakingContractVals[1],
+      stakingContractVals[2]
+    );
 
-    expect(earnedRewardAfterWithdrawReward.lt(earnedRewardBeforeWithdrawReward))
-      .to.be.true;
+    expect(earnedRewardAfterWithdrawReward.lt(earnedRewardBeforeWithdrawReward)).to.be.true;
     expect(earnedRewardAfterWithdrawReward.toString()).to.be.equal("0");
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
   });
   it("it should not mint reward when staking contract is not registered", async () => {
     const simpleStaking = await deployStaking();
@@ -778,45 +545,27 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     expect(tx.message).to.not.be.empty;
   });
   it("it should be able to distribute rewards when blockEnd passed but last Reward block was before blockend", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        goodCompoundStaking.address,
-        currentBlockNumber - 10,
-        currentBlockNumber + 50,
-        false
-      ] // set 10 gd per block
+      ["1000", goodCompoundStaking.address, currentBlockNumber - 10, currentBlockNumber + 50, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData);
     const stakingAmount = ethers.utils.parseEther("100");
     const initialGdBalance = await goodDollar.balanceOf(staker.address);
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
     await advanceBlocks(5);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount.div(2), false);
-    const gdBalanceAfterFirstWithdraw = await goodDollar.balanceOf(
-      staker.address
-    );
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount.div(2), false);
+    const gdBalanceAfterFirstWithdraw = await goodDollar.balanceOf(staker.address);
     const firstWithdrawBlockNumber = await ethers.provider.getBlockNumber();
     await advanceBlocks(60);
 
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount.div(2), false);
-    const gdBalanceAfterSecondWithdraw = await goodDollar.balanceOf(
-      staker.address
-    );
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount.div(2), false);
+    const gdBalanceAfterSecondWithdraw = await goodDollar.balanceOf(staker.address);
     expect(gdBalanceAfterFirstWithdraw).to.be.gt(initialGdBalance);
     expect(gdBalanceAfterFirstWithdraw.sub(initialGdBalance)).to.be.equal(
       BN.from("1000")
@@ -824,9 +573,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
         .div(2)
     );
     expect(gdBalanceAfterSecondWithdraw).to.be.gt(gdBalanceAfterFirstWithdraw);
-    expect(
-      gdBalanceAfterSecondWithdraw.sub(gdBalanceAfterFirstWithdraw)
-    ).to.be.equal(
+    expect(gdBalanceAfterSecondWithdraw.sub(gdBalanceAfterFirstWithdraw)).to.be.equal(
       BN.from("1000")
         .mul(currentBlockNumber + 50 - firstWithdrawBlockNumber)
         .div(2)
@@ -834,32 +581,20 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     ); // sub 1 due to precision loss
   });
   it("it should not earn rewards when currentBlock < blockStart", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        goodCompoundStaking.address,
-        currentBlockNumber + 100,
-        currentBlockNumber + 500,
-        false
-      ] // set 10 gd per block
+      ["1000", goodCompoundStaking.address, currentBlockNumber + 100, currentBlockNumber + 500, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData);
     const stakingAmount = ethers.utils.parseEther("100");
     const initialGdBalance = await goodDollar.balanceOf(staker.address);
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
     await advanceBlocks(50);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
     const gdBalanceAfterWithdraw = await goodDollar.balanceOf(staker.address);
 
     expect(initialGdBalance).to.be.gt(0);
@@ -867,32 +602,20 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
   });
 
   it("it should earn rewards when they stake before blockStart but keep their stake until after blockStart", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        goodCompoundStaking.address,
-        currentBlockNumber + 30,
-        currentBlockNumber + 500,
-        false
-      ] // set 10 gd per block
+      ["1000", goodCompoundStaking.address, currentBlockNumber + 30, currentBlockNumber + 500, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData);
     const stakingAmount = ethers.utils.parseEther("100");
     const initialGdBalance = await goodDollar.balanceOf(staker.address);
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
     await advanceBlocks(50);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
     const withdrawBlockNumber = await ethers.provider.getBlockNumber();
     const gdBalanceAfterWithdraw = await goodDollar.balanceOf(staker.address);
     expect(initialGdBalance).to.be.gt(0);
@@ -905,78 +628,42 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     );
   });
   it("should be able earn to 50% of rewards when owns 50% of total productivity", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    const ictrl = await ethers.getContractAt(
-      "Controller",
-      controller,
-      schemeMock
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+    const ictrl = await ethers.getContractAt("Controller", controller, schemeMock);
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     let encodedDataTwo = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        goodCompoundStaking.address,
-        currentBlockNumber - 10,
-        currentBlockNumber + 100,
-        false
-      ] // set 10 gd per block
+      ["1000", goodCompoundStaking.address, currentBlockNumber - 10, currentBlockNumber + 100, false] // set 10 gd per block
     );
 
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
     await dai["mint(address,uint256)"](signers[0].address, stakingAmount); // We use some different signer than founder since founder also UBI INTEREST collector
-    await dai
-      .connect(signers[0])
-      .approve(goodCompoundStaking.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
-    let stakerTwoGDAmountBeforeStake = await goodDollar.balanceOf(
-      signers[0].address
-    );
+    await dai.connect(signers[0]).approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
+    let stakerTwoGDAmountBeforeStake = await goodDollar.balanceOf(signers[0].address);
     let stakerGDAmountBeforeStake = await goodDollar.balanceOf(staker.address);
 
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
-    await goodCompoundStaking
-      .connect(signers[0])
-      .stake(stakingAmount, 100, false);
+    await goodCompoundStaking.connect(signers[0]).stake(stakingAmount, 100, false);
     await advanceBlocks(5);
 
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
-    await goodCompoundStaking
-      .connect(signers[0])
-      .withdrawStake(stakingAmount, false);
-    let stakerTwoGDAmountAfterStake = await goodDollar.balanceOf(
-      signers[0].address
-    );
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(signers[0]).withdrawStake(stakingAmount, false);
+    let stakerTwoGDAmountAfterStake = await goodDollar.balanceOf(signers[0].address);
     let stakerGDAmountAfterStake = await goodDollar.balanceOf(staker.address);
-    expect(
-      stakerTwoGDAmountAfterStake.sub(stakerTwoGDAmountBeforeStake).toString()
-    ).to.be.equal(
+    expect(stakerTwoGDAmountAfterStake.sub(stakerTwoGDAmountBeforeStake).toString()).to.be.equal(
       stakerGDAmountAfterStake.sub(stakerGDAmountBeforeStake).toString()
     );
   });
   it("Accumulated per share has enough precision when reward << totalproductivity", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
 
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     let encodedDataTwo = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        goodCompoundStaking.address,
-        currentBlockNumber - 10,
-        currentBlockNumber + 100,
-        false
-      ] // set 10 gd per block
+      ["1000", goodCompoundStaking.address, currentBlockNumber - 10, currentBlockNumber + 100, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedDataTwo, avatar, 0);
     const stakingAmount = ethers.utils.parseEther("1000000000");
@@ -987,32 +674,24 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const gdBalanceBeforeWithdraw = await goodDollar.balanceOf(founder.address);
     await goodCompoundStaking.withdrawStake(stakingAmount, false);
     const gdBalanceAfterWithdraw = await goodDollar.balanceOf(founder.address);
-    expect(
-      gdBalanceAfterWithdraw.sub(gdBalanceBeforeWithdraw).toString()
-    ).to.be.equal("2500");
+    expect(gdBalanceAfterWithdraw.sub(gdBalanceBeforeWithdraw).toString()).to.be.equal("2500");
   });
 
   it("it should not get any reward when donationPer set to 100", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
     let stakerGDAmountBeforeStake = await goodDollar.balanceOf(staker.address);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
     await advanceBlocks(4);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
     let stakerGDAmountAfterStake = await goodDollar.balanceOf(staker.address);
     expect(stakerGDAmountAfterStake).to.be.equal(stakerGDAmountBeforeStake);
   });
   it("it should be reverted when donation per set to different than 0 or 100", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
     const tx = await goodCompoundStaking
       .connect(staker)
       .stake(stakingAmount, 55, false)
@@ -1024,9 +703,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
 
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
 
@@ -1036,13 +713,14 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     const simpleStaking1 = await deployStaking();
 
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setStakingReward",
-      ["100", simpleStaking.address, 0, 10, false]
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData("setStakingReward", [
+      "100",
+      simpleStaking.address,
+      0,
+      10,
+      false
+    ]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
     await dai.connect(staker).approve(simpleStaking.address, stakingAmount);
@@ -1057,96 +735,59 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     expect(addressesToCollect[0]).to.be.equal(simpleStaking.address);
     expect(addressesToCollect[1]).to.be.equal(goodCompoundStaking.address);
 
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
-    encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setStakingReward",
-      ["100", simpleStaking.address, 0, 10, true]
-    );
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
+    encodedData = goodFundManagerFactory.interface.encodeFunctionData("setStakingReward", [
+      "100",
+      simpleStaking.address,
+      0,
+      10,
+      true
+    ]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
   });
 
   it("It should not collect interest when interest is lower than gas cost [ @skip-on-coverage ]", async () => {
-    await goodFundManager
-      .collectInterest([goodCompoundStaking.address], false)
-      .catch(e => e); // make sure there is no interest left
-
-    const stakingAmount = ethers.utils.parseEther("100");
-
-    await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
-
-    await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
-    const transaction = await goodFundManager
-      .collectInterest([goodCompoundStaking.address], false, {
+    await gasFeeOracle.setPrice(ethers.constants.WeiPerEther); //increase gas price so costs is more than ubi minted
+    await expect(
+      goodFundManager.collectInterest([], false, {
         gasLimit: 770000
       })
-      .catch(e => e);
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
-    expect(transaction.message).to.have.string(
-      "Collected interest value should be interestMultiplier x gas costs"
-    );
+    ).revertedWith("X*gas costs");
+    await gasFeeOracle.setPrice(25e8); //undo gas price
   });
 
   it("It should always collect interest without rewards when forced", async () => {
-    await goodFundManager
-      .collectInterest([goodCompoundStaking.address], false)
-      .catch(e => e); // make sure there is no interest left
+    await goodFundManager.collectInterest([goodCompoundStaking.address], false).catch(e => e); // make sure there is no interest left
 
     const stakingAmount = ethers.utils.parseEther("100");
 
     await dai["mint(address,uint256)"](staker.address, stakingAmount);
-    await dai
-      .connect(staker)
-      .approve(goodCompoundStaking.address, stakingAmount);
+    await dai.connect(staker).approve(goodCompoundStaking.address, stakingAmount);
 
     await goodCompoundStaking.connect(staker).stake(stakingAmount, 100, false);
-    const transaction = goodFundManager.collectInterest(
-      [goodCompoundStaking.address],
-      true,
-      {
-        gasLimit: 770000
-      }
-    );
+    const transaction = goodFundManager.collectInterest([goodCompoundStaking.address], true, {
+      gasLimit: 770000
+    });
 
     await expect(transaction).to.emit(goodFundManager, "FundsTransferred");
     const tx = await (await transaction).wait();
     const event = tx.events.find(e => e.event === "FundsTransferred");
     expect(event.args.gdReward).to.equal(0);
 
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakingAmount, false);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakingAmount, false);
   });
 
   it("It should sort array from lowest to highest ", async () => {
-    const goodFundManagerTestFactory = await ethers.getContractFactory(
-      "GoodFundManagerTest"
-    );
-    const goodFundManagerTest = await goodFundManagerTestFactory.deploy(
-      nameService.address
-    );
-    const addresses = [
-      founder.address,
-      staker.address,
-      cDAI.address,
-      cDAI1.address
-    ];
+    const goodFundManagerTestFactory = await ethers.getContractFactory("GoodFundManagerTest");
+    const goodFundManagerTest = await goodFundManagerTestFactory.deploy(nameService.address);
+    const addresses = [founder.address, staker.address, cDAI.address, cDAI1.address];
     const balances = [
       ethers.utils.parseEther("100"),
       ethers.utils.parseEther("85"),
       ethers.utils.parseEther("90"),
       ethers.utils.parseEther("30")
     ];
-    const sortedArrays = await goodFundManagerTest.testSorting(
-      balances,
-      addresses
-    );
+    const sortedArrays = await goodFundManagerTest.testSorting(balances, addresses);
     expect(sortedArrays[0][0]).to.be.equal(ethers.utils.parseEther("30"));
     expect(sortedArrays[0][3]).to.be.equal(ethers.utils.parseEther("100"));
     expect(sortedArrays[1][3]).to.be.equal(founder.address);
@@ -1154,21 +795,24 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
   });
 
   it("It should not be able to calc and sort array when there is no active staking contract", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setStakingReward",
-      ["100", goodCompoundStaking.address, 0, 10, true]
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData("setStakingReward", [
+      "100",
+      goodCompoundStaking.address,
+      0,
+      10,
+      true
+    ]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
-    const contractsToInterestCollected =
-      await goodFundManager.calcSortedContracts();
+    const contractsToInterestCollected = await goodFundManager.calcSortedContracts();
     expect(contractsToInterestCollected.length).to.be.equal(0);
-    encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setStakingReward",
-      ["100", goodCompoundStaking.address, 100, 1000, false]
-    );
+    encodedData = goodFundManagerFactory.interface.encodeFunctionData("setStakingReward", [
+      "100",
+      goodCompoundStaking.address,
+      100,
+      1000,
+      false
+    ]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
   });
 
@@ -1176,107 +820,72 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const currentBlockNumber = await ethers.provider.getBlockNumber();
     const currentBlock = await ethers.provider.getBlock(currentBlockNumber);
 
-    await ethers.provider.send("evm_setNextBlockTimestamp", [
-      currentBlock.timestamp + 5185020
-    ]);
+    await ethers.provider.send("evm_setNextBlockTimestamp", [currentBlock.timestamp + 5185020]);
     await ethers.provider.send("evm_mine", []);
-    const collectableContracts = await goodFundManager
-      .calcSortedContracts()
-      .catch(e => e);
-    const tx = await goodFundManager
-      .collectInterest([goodCompoundStaking.address], false)
-      .catch(e => e);
-    expect(tx.message).to.have.string(
-      "Collected interest value should be larger than spent gas costs"
-    );
+    const collectableContracts = await goodFundManager.calcSortedContracts().catch(e => e);
+    await expect(goodFundManager.collectInterest([goodCompoundStaking.address], false)).revertedWith("< gas costs");
   });
 
   it("Avatar should be able to set gd minting gas amount", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setGasCost",
-      ["140000"]
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData("setGasCost", ["140000"]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
   });
   it("Avatar should be able to set collectInterestTimeThreshold", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setCollectInterestTimeThreshold",
-      ["5184000"]
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData("setCollectInterestTimeThreshold", [
+      "5184000"
+    ]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
   });
   it("Avatar should be able set interestMultiplier", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setInterestMultiplier",
-      ["4"]
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData("setInterestMultiplier", ["4"]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
   });
   it("Avatar should be able set gasCostExceptInterestCollect", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setGasCostExceptInterestCollect",
-      ["650000"]
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData("setGasCostExceptInterestCollect", [
+      "650000"
+    ]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
   });
 
   it("It should be able to collect Interest from non DAI or cDAI staking contract [ @skip-on-coverage ]", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-
-    const simpleStaking = await goodCompoundStakingFactory
-      .deploy()
-      .then(async contract => {
-        await contract.init(
-          bat.address,
-          cBat.address,
-          nameService.address,
-          "Good BaT",
-          "gBAT",
-          "50",
-          batUsdOracle.address,
-          compUsdOracle.address,
-          [bat.address, dai.address]
-        );
-        return contract;
-      });
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
+
+    const simpleStaking = await goodCompoundStakingFactory.deploy().then(async contract => {
+      await contract.init(
+        bat.address,
+        cBat.address,
+        nameService.address,
+        "Good BaT",
+        "gBAT",
+        "50",
+        batUsdOracle.address,
+        compUsdOracle.address,
+        [bat.address, dai.address]
+      );
+      return contract;
+    });
 
-    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
-      "setStakingReward",
-      ["100", simpleStaking.address, 10, 10000, false]
-    );
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData("setStakingReward", [
+      "100",
+      simpleStaking.address,
+      10,
+      10000,
+      false
+    ]);
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
-    encodedData = goodCompoundStakingFactory.interface.encodeFunctionData(
-      "setcollectInterestGasCostParams",
-      ["250000", "150000"]
-    );
+    encodedData = goodCompoundStakingFactory.interface.encodeFunctionData("setcollectInterestGasCostParams", [
+      "250000",
+      "150000"
+    ]);
     await genericCall(simpleStaking.address, encodedData, avatar, 0);
-    await bat["mint(address,uint256)"](
-      founder.address,
-      ethers.utils.parseEther("1001000")
-    );
+    await bat["mint(address,uint256)"](founder.address, ethers.utils.parseEther("1001000"));
     await bat.transfer(cBat.address, ethers.utils.parseEther("1000000")); // We should put extra BAT to mock cBAT contract in order to provide interest
-    await dai["mint(address,uint256)"](
-      founder.address,
-      ethers.utils.parseEther("1000000")
-    );
-    await dai.approve(
-      goodCompoundStaking.address,
-      ethers.utils.parseEther("100")
-    );
+    await dai["mint(address,uint256)"](founder.address, ethers.utils.parseEther("1000000"));
+    await dai.approve(goodCompoundStaking.address, ethers.utils.parseEther("100"));
     await goodCompoundStaking.stake(ethers.utils.parseEther("100"), 100, false);
     await bat.approve(simpleStaking.address, ethers.utils.parseEther("100"));
     await simpleStaking.stake(ethers.utils.parseEther("100"), 100, false);
@@ -1291,15 +900,10 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       gasLimit: 1500000
     });
     await simpleStaking.withdrawStake(ethers.utils.parseEther("100"), false);
-    await goodCompoundStaking.withdrawStake(
-      ethers.utils.parseEther("100"),
-      false
-    );
+    await goodCompoundStaking.withdrawStake(ethers.utils.parseEther("100"), false);
   });
   it("It should redeem underlying token to DAI", async () => {
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
+    const goodFundManagerFactory = await ethers.getContractFactory("GoodFundManager");
 
     const simpleStaking = await goodCompoundStakingTestFactory.deploy(
       bat.address,
@@ -1313,18 +917,10 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       [bat.address, dai.address]
     );
     await setDAOAddress("RESERVE", simpleStaking.address);
-    await bat["mint(address,uint256)"](
-      cBat.address,
-      ethers.utils.parseEther("1000")
-    );
-    await cBat["mint(address,uint256)"](
-      simpleStaking.address,
-      ethers.utils.parseUnits("1000", 8)
-    );
+    await bat["mint(address,uint256)"](cBat.address, ethers.utils.parseEther("1000"));
+    await cBat["mint(address,uint256)"](simpleStaking.address, ethers.utils.parseUnits("1000", 8));
     const balanceBeforeRedeem = await dai.balanceOf(simpleStaking.address);
-    await simpleStaking.redeemUnderlyingToDAITest(
-      ethers.utils.parseUnits("10", 8)
-    );
+    await simpleStaking.redeemUnderlyingToDAITest(ethers.utils.parseUnits("10", 8));
     await setDAOAddress("RESERVE", goodReserve.address);
     const balanceAfterRedeem = await dai.balanceOf(simpleStaking.address);
     const accAmountPerShare = await simpleStaking.accAmountPerShare();
@@ -1332,9 +928,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     expect(balanceAfterRedeem.gt(balanceBeforeRedeem)).to.be.true;
   });
   it("it should reverted when someone trying to call rewardsMinted function beside fundmanager", async () => {
-    const tx = await goodCompoundStaking
-      .rewardsMinted(founder.address, "1000", 50, 100)
-      .catch(e => e);
+    const tx = await goodCompoundStaking.rewardsMinted(founder.address, "1000", 50, 100).catch(e => e);
     expect(tx.message).to.not.empty;
   });
 
@@ -1350,12 +944,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       compUsdOracle.address,
       [bat.address, dai.address]
     );
-    await expect(
-      simpleStaking.decreaseProductivityTest(
-        founder.address,
-        ethers.utils.parseEther("100")
-      )
-    ).reverted;
+    await expect(simpleStaking.decreaseProductivityTest(founder.address, ethers.utils.parseEther("100"))).reverted;
   });
 
   it("User pending reward should be zero when there is no stake of user", async () => {
@@ -1370,15 +959,12 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       compUsdOracle.address,
       [bat.address, dai.address]
     );
-    let encodedData =
-      goodCompoundStakingTestFactory.interface.encodeFunctionData(
-        "setcollectInterestGasCostParams",
-        ["250000", "150000"]
-      );
+    let encodedData = goodCompoundStakingTestFactory.interface.encodeFunctionData("setcollectInterestGasCostParams", [
+      "250000",
+      "150000"
+    ]);
     await genericCall(simpleStaking.address, encodedData, avatar, 0);
-    const stakingContractVals = await goodFundManager.rewardsForStakingContract(
-      goodCompoundStaking.address
-    );
+    const stakingContractVals = await goodFundManager.rewardsForStakingContract(goodCompoundStaking.address);
     const pendingReward = await simpleStaking.getUserPendingReward(
       founder.address,
       stakingContractVals[0],
@@ -1399,16 +985,11 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       compUsdOracle.address,
       [bat.address, dai.address]
     );
-    const tx = await simpleStaking
-      .transfer(staker.address, "10000")
-      .catch(e => e);
+    const tx = await simpleStaking.transfer(staker.address, "10000").catch(e => e);
     expect(tx.message).to.have.string("ERC20: transfer amount exceeds balance");
   });
 
-  async function addLiquidity(
-    token0Amount: BigNumber,
-    token1Amount: BigNumber
-  ) {
+  async function addLiquidity(token0Amount: BigNumber, token1Amount: BigNumber) {
     await bat.transfer(pair.address, token0Amount);
     await dai.transfer(pair.address, token1Amount);
     await pair.mint(founder.address);
@@ -1420,9 +1001,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       ["1000", signers[0].address, 10, 1000, true] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData);
-    let data = await goodFundManager.rewardsForStakingContract(
-      signers[0].address
-    );
+    let data = await goodFundManager.rewardsForStakingContract(signers[0].address);
     expect(data.isBlackListed).to.equal(true);
 
     encodedData = goodFundManager.interface.encodeFunctionData(
@@ -1451,8 +1030,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       ["1000", simpleStaking1.address, 10, 1000, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
-    const activeContractsCount =
-      await goodFundManager.getActiveContractsCount();
+    const activeContractsCount = await goodFundManager.getActiveContractsCount();
 
     const simpleStaking = await goodCompoundStakingTestFactory.deploy(
       bat.address,
@@ -1470,8 +1048,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       ["1000", simpleStaking.address, 10, 1000, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
-    const activeContractsCountAfterAdded =
-      await goodFundManager.getActiveContractsCount();
+    const activeContractsCountAfterAdded = await goodFundManager.getActiveContractsCount();
 
     expect(activeContractsCountAfterAdded).equal(activeContractsCount.add(1));
 
@@ -1481,16 +1058,13 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     );
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
 
-    const activeContractsCountAfterRemoved =
-      await goodFundManager.getActiveContractsCount();
+    const activeContractsCountAfterRemoved = await goodFundManager.getActiveContractsCount();
     const lastActiveContractAfterRemove = await goodFundManager.activeContracts(
       activeContractsCountAfterRemoved.sub(1)
     );
 
     expect(lastActiveContractAfterRemove).to.be.equal(simpleStaking.address);
-    expect(activeContractsCountAfterAdded).to.be.eq(
-      activeContractsCountAfterRemoved
-    );
+    expect(activeContractsCountAfterAdded).to.be.eq(activeContractsCountAfterRemoved);
 
     expect(activeContractsCount).to.be.lt(activeContractsCountAfterRemoved);
   });
@@ -1511,13 +1085,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const rewardsPerBlock = BN.from("1000");
     let encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        rewardsPerBlock,
-        simpleStaking1.address,
-        currentBlock - 10,
-        currentBlock + 1000,
-        false
-      ] // set 10 gd per block
+      [rewardsPerBlock, simpleStaking1.address, currentBlock - 10, currentBlock + 1000, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
     const stakingAmount = ethers.utils.parseEther("100");
@@ -1525,79 +1093,34 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     await bat["mint(address,uint256)"](staker.address, stakingAmount);
     await bat["mint(address,uint256)"](signers[0].address, stakingAmount);
     await bat["mint(address,uint256)"](signers[1].address, stakingAmount);
-    await bat["approve(address,uint256)"](
-      simpleStaking1.address,
-      stakingAmount
-    );
-    await bat
-      .connect(staker)
-      ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
-    await bat
-      .connect(signers[0])
-      ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
-    await bat
-      .connect(signers[1])
-      ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
-    const stakerOneStakeBlockNumber =
-      (await ethers.provider.getBlockNumber()) + 1;
-    await simpleStaking1["stake(uint256,uint256,bool)"](
-      stakingAmount,
-      "0",
-      false
-    );
-    const stakerOneGdBalanceAfterStake = await goodDollar.balanceOf(
-      founder.address
-    );
-    const stakerTwoStakeBlockNumber =
-      (await ethers.provider.getBlockNumber()) + 1;
-    await simpleStaking1
-      .connect(staker)
-      ["stake(uint256,uint256,bool)"](stakingAmount.div(5), "0", false);
-    const stakerTwoGdBalanceAfterStake = await goodDollar.balanceOf(
-      staker.address
-    );
-    const stakerThreeStakeBlockNumber =
-      (await ethers.provider.getBlockNumber()) + 1;
-    await simpleStaking1
-      .connect(signers[0])
-      ["stake(uint256,uint256,bool)"](stakingAmount.div(4), "0", false);
-    const stakerThreeGdBalanceAfterStake = await goodDollar.balanceOf(
-      signers[0].address
-    );
-    const stakerFourStakeBlockNumber =
-      (await ethers.provider.getBlockNumber()) + 1;
-    await simpleStaking1
-      .connect(signers[1])
-      ["stake(uint256,uint256,bool)"](stakingAmount.div(10), "0", false);
-    const stakerFourGdBalanceAfterStake = await goodDollar.balanceOf(
-      signers[1].address
-    );
+    await bat["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    await bat.connect(staker)["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    await bat.connect(signers[0])["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    await bat.connect(signers[1])["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    const stakerOneStakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
+    await simpleStaking1["stake(uint256,uint256,bool)"](stakingAmount, "0", false);
+    const stakerOneGdBalanceAfterStake = await goodDollar.balanceOf(founder.address);
+    const stakerTwoStakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
+    await simpleStaking1.connect(staker)["stake(uint256,uint256,bool)"](stakingAmount.div(5), "0", false);
+    const stakerTwoGdBalanceAfterStake = await goodDollar.balanceOf(staker.address);
+    const stakerThreeStakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
+    await simpleStaking1.connect(signers[0])["stake(uint256,uint256,bool)"](stakingAmount.div(4), "0", false);
+    const stakerThreeGdBalanceAfterStake = await goodDollar.balanceOf(signers[0].address);
+    const stakerFourStakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
+    await simpleStaking1.connect(signers[1])["stake(uint256,uint256,bool)"](stakingAmount.div(10), "0", false);
+    const stakerFourGdBalanceAfterStake = await goodDollar.balanceOf(signers[1].address);
     await advanceBlocks(10);
     await simpleStaking1["withdrawStake(uint256,bool)"](stakingAmount, false);
     const stakerOneWithdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const stakerOneGdBalanceAfterWithdraw = await goodDollar.balanceOf(
-      founder.address
-    );
-    await simpleStaking1
-      .connect(staker)
-      ["withdrawStake(uint256,bool)"](stakingAmount.div(5), false);
+    const stakerOneGdBalanceAfterWithdraw = await goodDollar.balanceOf(founder.address);
+    await simpleStaking1.connect(staker)["withdrawStake(uint256,bool)"](stakingAmount.div(5), false);
     const stakerTwoWithdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const stakerTwoGdBalanceAfterWithdraw = await goodDollar.balanceOf(
-      staker.address
-    );
-    await simpleStaking1
-      .connect(signers[0])
-      ["withdrawStake(uint256,bool)"](stakingAmount.div(4), false);
+    const stakerTwoGdBalanceAfterWithdraw = await goodDollar.balanceOf(staker.address);
+    await simpleStaking1.connect(signers[0])["withdrawStake(uint256,bool)"](stakingAmount.div(4), false);
 
-    const stakerThreeGdBalanceAfterWithdraw = await goodDollar.balanceOf(
-      signers[0].address
-    );
-    await simpleStaking1
-      .connect(signers[1])
-      ["withdrawStake(uint256,bool)"](stakingAmount.div(10), false);
-    const stakerFourGdBalanceAfterWithdraw = await goodDollar.balanceOf(
-      signers[1].address
-    );
+    const stakerThreeGdBalanceAfterWithdraw = await goodDollar.balanceOf(signers[0].address);
+    await simpleStaking1.connect(signers[1])["withdrawStake(uint256,bool)"](stakingAmount.div(10), false);
+    const stakerFourGdBalanceAfterWithdraw = await goodDollar.balanceOf(signers[1].address);
     const stakerOneCalculatedReward = rewardsPerBlock
       .add(rewardsPerBlock.mul(100).div(120)) // there is new staker so total stake units are 120 if call full stakingamount is 100
       .add(rewardsPerBlock.mul(100).div(145)) // there is new staker so total stake units are 145
@@ -1643,27 +1166,15 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       .add(rewardsPerBlock)
       .div(BN.from("2"))
       .add("1");
-    expect(stakerOneGdBalanceAfterWithdraw).to.be.equal(
-      stakerOneGdBalanceAfterStake.add(stakerOneCalculatedReward)
-    );
-    expect(stakerTwoGdBalanceAfterWithdraw).to.be.equal(
-      stakerTwoGdBalanceAfterStake.add(stakerTwoCalculatedReward)
-    );
+    expect(stakerOneGdBalanceAfterWithdraw).to.be.equal(stakerOneGdBalanceAfterStake.add(stakerOneCalculatedReward));
+    expect(stakerTwoGdBalanceAfterWithdraw).to.be.equal(stakerTwoGdBalanceAfterStake.add(stakerTwoCalculatedReward));
     expect(stakerThreeGdBalanceAfterWithdraw).to.be.equal(
       stakerThreeGdBalanceAfterStake.add(stakerThreeCalculatedReward)
     );
-    expect(stakerFourGdBalanceAfterWithdraw).to.be.equal(
-      stakerFourGdBalanceAfterStake.add(stakerFourCalculatedReward)
-    );
+    expect(stakerFourGdBalanceAfterWithdraw).to.be.equal(stakerFourGdBalanceAfterStake.add(stakerFourCalculatedReward));
     encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        rewardsPerBlock,
-        simpleStaking1.address,
-        currentBlock - 10,
-        currentBlock + 1000,
-        true
-      ] // set 10 gd per block
+      [rewardsPerBlock, simpleStaking1.address, currentBlock - 10, currentBlock + 1000, true] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
   });
@@ -1684,53 +1195,26 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const rewardsPerBlock = BN.from("100");
     let encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        rewardsPerBlock,
-        simpleStaking1.address,
-        currentBlock - 10,
-        currentBlock + 1000,
-        false
-      ] // set 1 gd per block
+      [rewardsPerBlock, simpleStaking1.address, currentBlock - 10, currentBlock + 1000, false] // set 1 gd per block
     );
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
     const stakingAmount = ethers.utils.parseEther("100");
     await bat["mint(address,uint256)"](founder.address, stakingAmount);
     await bat["mint(address,uint256)"](staker.address, stakingAmount);
-    await bat["approve(address,uint256)"](
-      simpleStaking1.address,
-      stakingAmount
-    );
-    await bat
-      .connect(staker)
-      ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
-    await simpleStaking1["stake(uint256,uint256,bool)"](
-      stakingAmount,
-      "0",
-      false
-    );
-    const founderGdBalanceAfterStake = await goodDollar.balanceOf(
-      founder.address
-    );
+    await bat["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    await bat.connect(staker)["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    await simpleStaking1["stake(uint256,uint256,bool)"](stakingAmount, "0", false);
+    const founderGdBalanceAfterStake = await goodDollar.balanceOf(founder.address);
     const stakerStakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
-    await simpleStaking1
-      .connect(staker)
-      ["stake(uint256,uint256,bool)"](stakingAmount.div(20), "0", false); // should get ~0.009 gd each block
-    const stakerGdBalanceAfterStake = await goodDollar.balanceOf(
-      staker.address
-    );
+    await simpleStaking1.connect(staker)["stake(uint256,uint256,bool)"](stakingAmount.div(20), "0", false); // should get ~0.009 gd each block
+    const stakerGdBalanceAfterStake = await goodDollar.balanceOf(staker.address);
     await advanceBlocks(100);
-    await simpleStaking1
-      .connect(staker)
-      ["withdrawStake(uint256,bool)"](stakingAmount.div(20), false);
+    await simpleStaking1.connect(staker)["withdrawStake(uint256,bool)"](stakingAmount.div(20), false);
     const stakerWithdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const stakerGdBalanceAfterWithdraw = await goodDollar.balanceOf(
-      staker.address
-    );
+    const stakerGdBalanceAfterWithdraw = await goodDollar.balanceOf(staker.address);
     await simpleStaking1["withdrawStake(uint256,bool)"](stakingAmount, false);
     const founderWithdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const founderGdBalanceAfterWithdraw = await goodDollar.balanceOf(
-      founder.address
-    );
+    const founderGdBalanceAfterWithdraw = await goodDollar.balanceOf(founder.address);
     const stakerCalculatedRewards = rewardsPerBlock
       .mul(5)
       .mul(stakerWithdrawBlockNumber - stakerStakeBlockNumber)
@@ -1746,12 +1230,8 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
           .div(105)
       )
       .div(BN.from("2"));
-    expect(
-      stakerGdBalanceAfterWithdraw.sub(stakerGdBalanceAfterStake)
-    ).to.be.equal(stakerCalculatedRewards);
-    expect(
-      founderGdBalanceAfterWithdraw.sub(founderGdBalanceAfterStake)
-    ).to.be.equal(founderCalculatedRewards);
+    expect(stakerGdBalanceAfterWithdraw.sub(stakerGdBalanceAfterStake)).to.be.equal(stakerCalculatedRewards);
+    expect(founderGdBalanceAfterWithdraw.sub(founderGdBalanceAfterStake)).to.be.equal(founderCalculatedRewards);
   });
   it("it should calculate price of spent gas in DAI properly", async () => {
     const gasAmount = BN.from("1100000"); // 1.1M
@@ -1761,10 +1241,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       .mul(BN.from("10").pow(18)) // we multiply with 1e18 so when we divide it to DAI/ETH rate we would get result in 18 decimals
       .div(daiToEthRate) // we divide gas price to DAI/ETH rate so we can get gas price in DAI
       .mul(gasAmount); // Result is in DAI and we accept 1$ = 1DAI
-    const onChainResult = await goodFundManager.getGasPriceIncDAIorDAI(
-      gasAmount,
-      true
-    );
+    const onChainResult = await goodFundManager.getGasPriceIncDAIorDAI(gasAmount, true);
     expect(calculatedResult).to.be.gt(0);
     expect(onChainResult).to.be.equal(calculatedResult);
   });
@@ -1778,10 +1255,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       .mul(BN.from("10").pow(28)) // we multiply it with mantissa which is 18 + tokenDecimals - cTokenDecimals so token is in 18 decimals and cToken is in 8 decimals therefore difference is 10 for more detail https://compound.finance/docs#protocol-math
       .div(await cDAI.exchangeRateStored()); // then we divide it exchange rate in order to get result
     const calculatedResult = gasPriceInCdai.mul(gasAmount);
-    const onChainResult = await goodFundManager.getGasPriceIncDAIorDAI(
-      gasAmount,
-      false
-    );
+    const onChainResult = await goodFundManager.getGasPriceIncDAIorDAI(gasAmount, false);
     expect(calculatedResult).to.be.gt(0);
     expect(onChainResult).to.be.equal(calculatedResult);
   });
@@ -1808,14 +1282,8 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     await bat.approve(simpleStaking.address, stakingAmount);
     await simpleStaking.stake(stakingAmount, "0", false);
     await cBat.increasePriceWithMultiplier(100);
-    const currentGainsWithBothFalse = await simpleStaking.currentGains(
-      false,
-      false
-    );
-    const currentGainsWithBothTrue = await simpleStaking.currentGains(
-      true,
-      true
-    );
+    const currentGainsWithBothFalse = await simpleStaking.currentGains(false, false);
+    const currentGainsWithBothTrue = await simpleStaking.currentGains(true, true);
     await simpleStaking.withdrawStake(stakingAmount, false);
     expect(currentGainsWithBothFalse[3]).to.be.equal(0);
     expect(currentGainsWithBothFalse[4]).to.be.equal(0);
@@ -1830,13 +1298,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
   it("it should collectInterest when there is comp rewards but there is no interest from interest token for nonDAI-cDAI staking contract", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
-    let { simpleStaking } = await compTestHelper(
-      bat,
-      cBat,
-      batUsdOracle,
-      stakingAmount,
-      false
-    );
+    let { simpleStaking } = await compTestHelper(bat, cBat, batUsdOracle, stakingAmount, false);
 
     const currentGains = await simpleStaking.currentGains(false, true);
     expect(currentGains[4]).to.be.equal("0");
@@ -1851,13 +1313,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
   it("it should collectInterest from interest token along with comp rewards for nonDAI-cDAI staking contract [ @skip-on-coverage ]", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
-    let { simpleStaking } = await compTestHelper(
-      bat,
-      cBat,
-      batUsdOracle,
-      stakingAmount,
-      true
-    );
+    let { simpleStaking } = await compTestHelper(bat, cBat, batUsdOracle, stakingAmount, true);
 
     const currentGains = await simpleStaking.currentGains(false, true);
     expect(currentGains[4]).to.be.equal("4"); // it's not equal due to precision loss
@@ -1872,13 +1328,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
   it("it should collectInterest when there is comp rewards but there is no interest from interest token for DAI-cDAI staking contract", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
-    let { simpleStaking } = await compTestHelper(
-      dai,
-      cDAI,
-      daiUsdOracle,
-      stakingAmount,
-      false
-    );
+    let { simpleStaking } = await compTestHelper(dai, cDAI, daiUsdOracle, stakingAmount, false);
 
     const currentGains = await simpleStaking.currentGains(false, true);
     expect(currentGains[4]).to.be.equal("0");
@@ -1892,13 +1342,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
   });
   it("it should collectInterest from interest token along with comp rewards for DAI-cDAI staking contract [ @skip-on-coverage ]", async () => {
     const stakingAmount = ethers.utils.parseEther("100");
-    let { simpleStaking } = await compTestHelper(
-      dai,
-      cDAI,
-      daiUsdOracle,
-      stakingAmount,
-      true
-    );
+    let { simpleStaking } = await compTestHelper(dai, cDAI, daiUsdOracle, stakingAmount, true);
 
     const currentGains = await simpleStaking.currentGains(false, true);
     expect(currentGains[4]).to.be.lt("200"); //should be equal 0 but due to precision loss give some offset so make sure less than 200
@@ -1925,13 +1369,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     );
     let encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        simpleStaking.address,
-        currentBlockNumber - 5,
-        currentBlockNumber + 1000,
-        false
-      ] // set 10 gd per block
+      ["1000", simpleStaking.address, currentBlockNumber - 5, currentBlockNumber + 1000, false] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData);
     const rewardsPerBlock = BN.from("1000");
@@ -1948,21 +1386,11 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const GDBalanceAfterWithdraw = await goodDollar.balanceOf(founder.address);
 
     expect(GDBalanceAfterWithdraw).to.be.equal(
-      GDBalanceAfterStake.add(
-        rewardsPerBlock
-          .mul(withdrawRewardsBlockNumber - stakeBlockNumber)
-          .div(BN.from("2"))
-      )
+      GDBalanceAfterStake.add(rewardsPerBlock.mul(withdrawRewardsBlockNumber - stakeBlockNumber).div(BN.from("2")))
     );
     encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        simpleStaking.address,
-        currentBlockNumber - 5,
-        currentBlockNumber + 1000,
-        true
-      ] // set 10 gd per block
+      ["1000", simpleStaking.address, currentBlockNumber - 5, currentBlockNumber + 1000, true] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData);
   });
@@ -1981,70 +1409,37 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     );
     let encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        simpleStaking.address,
-        currentBlockNumber - 5,
-        currentBlockNumber + 1000,
-        false
-      ] // set 10 gd per block
-    );
-    const overMintTestFactory = await ethers.getContractFactory(
-      "OverMintTesterRegularStake"
-    );
-    const overMintTester = await overMintTestFactory.deploy(
-      bat.address,
-      simpleStaking.address,
-      goodDollar.address
+      ["1000", simpleStaking.address, currentBlockNumber - 5, currentBlockNumber + 1000, false] // set 10 gd per block
     );
+    const overMintTestFactory = await ethers.getContractFactory("OverMintTesterRegularStake");
+    const overMintTester = await overMintTestFactory.deploy(bat.address, simpleStaking.address, goodDollar.address);
     await genericCall(goodFundManager.address, encodedData);
     const stakingAmount = ethers.utils.parseEther("100");
     await bat["mint(address,uint256)"](overMintTester.address, stakingAmount);
     const rewardsPerBlock = BN.from("1000");
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await overMintTester.stake();
-    const GDBalanceAfterStake = await goodDollar.balanceOf(
-      overMintTester.address
-    );
+    const GDBalanceAfterStake = await goodDollar.balanceOf(overMintTester.address);
     await advanceBlocks(100);
     await overMintTester.overMintTest();
     const withdrawRewardsBlockNumber = await ethers.provider.getBlockNumber();
-    const GDBalanceAfterWithdrawReward = await goodDollar.balanceOf(
-      overMintTester.address
-    );
+    const GDBalanceAfterWithdrawReward = await goodDollar.balanceOf(overMintTester.address);
     await advanceBlocks(20);
     await overMintTester.overMintTest();
-    const secondWithdrawRewardsBlockNumber =
-      await ethers.provider.getBlockNumber();
-    const GDBalanceAfterSecondWithdrawReward = await goodDollar.balanceOf(
-      overMintTester.address
-    );
+    const secondWithdrawRewardsBlockNumber = await ethers.provider.getBlockNumber();
+    const GDBalanceAfterSecondWithdrawReward = await goodDollar.balanceOf(overMintTester.address);
 
     expect(GDBalanceAfterWithdrawReward).to.be.gt(GDBalanceAfterStake);
     expect(GDBalanceAfterWithdrawReward.sub(GDBalanceAfterStake)).to.be.equal(
-      rewardsPerBlock
-        .mul(withdrawRewardsBlockNumber - stakeBlockNumber)
-        .div(BN.from("2"))
-    );
-    expect(GDBalanceAfterSecondWithdrawReward).to.be.gt(
-      GDBalanceAfterWithdrawReward
+      rewardsPerBlock.mul(withdrawRewardsBlockNumber - stakeBlockNumber).div(BN.from("2"))
     );
-    expect(
-      GDBalanceAfterSecondWithdrawReward.sub(GDBalanceAfterWithdrawReward)
-    ).to.be.equal(
-      rewardsPerBlock
-        .mul(secondWithdrawRewardsBlockNumber - withdrawRewardsBlockNumber)
-        .div(BN.from("2"))
+    expect(GDBalanceAfterSecondWithdrawReward).to.be.gt(GDBalanceAfterWithdrawReward);
+    expect(GDBalanceAfterSecondWithdrawReward.sub(GDBalanceAfterWithdrawReward)).to.be.equal(
+      rewardsPerBlock.mul(secondWithdrawRewardsBlockNumber - withdrawRewardsBlockNumber).div(BN.from("2"))
     );
     encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
-      [
-        "1000",
-        simpleStaking.address,
-        currentBlockNumber - 5,
-        currentBlockNumber + 1000,
-        true
-      ] // set 10 gd per block
+      ["1000", simpleStaking.address, currentBlockNumber - 5, currentBlockNumber + 1000, true] // set 10 gd per block
     );
     await genericCall(goodFundManager.address, encodedData);
   });
@@ -2077,22 +1472,15 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     await simpleStaking.stake(stakingAmount, "0", false);
     let currentGains = await simpleStaking.currentGains(false, true);
     expect(currentGains[4]).to.be.equal("0");
-    await comp["mint(address,uint256)"](
-      simpleStaking.address,
-      ethers.utils.parseEther("10")
-    );
+    await comp["mint(address,uint256)"](simpleStaking.address, ethers.utils.parseEther("10"));
     currentGains = await simpleStaking.currentGains(false, true);
     const compPriceInDollar = await compUsdOracle.latestAnswer();
-    expect(currentGains[4]).to.be.equal(
-      BigNumber.from("10").mul(compPriceInDollar)
-    );
+    expect(currentGains[4]).to.be.equal(BigNumber.from("10").mul(compPriceInDollar));
     if (increasePriceOfCtoken) {
       await cToken.increasePriceWithMultiplier("1000");
     }
 
-    const contractAddressesToBeCollected = await goodFundManager
-      .connect(staker)
-      .calcSortedContracts();
+    const contractAddressesToBeCollected = await goodFundManager.connect(staker).calcSortedContracts();
     const addressesToCollect = contractAddressesToBeCollected.map(x => x[0]);
     await goodFundManager.collectInterest(addressesToCollect, false);
     return { simpleStaking };