@gooddollar/goodprotocol 2.0.25-beta.8 → 2.0.25

package/test/governance/CompoundVotingMachine.state.test.ts

@@ -107,6 +107,9 @@ describe("CompoundVotingMachine#States", () => {
     votePeriod = await gov.votingPeriod().then(_ => _.toNumber());
     queuePeriod = await gov.queuePeriod().then(_ => _.toNumber());
     gracePeriod = await gov.gracePeriod().then(_ => _.toNumber());
+
+    //disable guardian
+    await gov.renounceGuardian()
   });
 
   it("Invalid for proposal not found", async () => {
@@ -130,13 +133,13 @@ describe("CompoundVotingMachine#States", () => {
     await grep.delegateTo(actor.address);
     await gov
       .connect(actor)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let newProposalId = await gov.proposalCount();
 
     // send away the delegates
@@ -212,13 +215,13 @@ describe("CompoundVotingMachine#States", () => {
     await advanceBlocks(1);
     await gov
       .connect(actor)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let proposalId = await gov.latestProposalIds(actor.address);
     await advanceBlocks(1);
     await gov.connect(actor).castVote(proposalId, false);
@@ -237,13 +240,13 @@ describe("CompoundVotingMachine#States", () => {
     await advanceBlocks(1);
     await gov
       .connect(actor)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let proposalId = await gov.latestProposalIds(actor.address);
     await advanceBlocks(1);
     await gov.connect(actor).castVote(proposalId, true);
@@ -310,13 +313,13 @@ describe("CompoundVotingMachine#States", () => {
     await advanceBlocks(1);
     await gov
       .connect(signers[0])
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let proposalId = await gov.proposalCount();
     await advanceBlocks(1);
 

package/test/governance/StakersDistribution.test.ts

@@ -652,7 +652,6 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     );
     await advanceBlocks(4);
     const gdaoBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
-    console.log({ gdaoBalanceBeforeWithdraw, rewardsPerBlock });
     await simpleStaking1.connect(staker).withdrawStake(stakingAmount, false);
     const withdrawBlockNumber = await ethers.provider.getBlockNumber();
     await stakersDistribution.claimReputation(staker.address, [
@@ -903,8 +902,8 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
         staker.address,
         simpleStaking1.address
       );
-    expect(userMintedRewardAfterStake.eq(0));
-    expect(userPendingRewardAfterStake.gt(0));
+    expect(userMintedRewardAfterStake).eq(0);
+    expect(userPendingRewardAfterStake).gt(0);
 
     await stakersDistribution.claimReputation(staker.address, [
       simpleStaking1.address
@@ -915,8 +914,8 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
         staker.address,
         simpleStaking1.address
       );
-    expect(userMintedRewardAfterClaim.gt(0));
-    expect(userPendingRewardAfterClaim.eq(0));
+    expect(userMintedRewardAfterClaim).gt(0);
+    expect(userPendingRewardAfterClaim).eq(0);
   });
 
   async function getUserMintedAndPendingRewards(
@@ -933,4 +932,79 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
 
     return [userMintedReward, userPendingReward];
   }
+
+  it("should update user rewards when monthly rate has changed", async () => {
+    const goodFundManagerFactory = await ethers.getContractFactory(
+      "GoodFundManager"
+    );
+
+    const simpleStaking1 = await deployDaiStaking();
+    const ictrl = await ethers.getContractAt(
+      "Controller",
+      controller,
+      schemeMock
+    );
+    const currentBlockNumber = await ethers.provider.getBlockNumber();
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
+      "setStakingReward",
+      [
+        "100000",
+        simpleStaking1.address,
+        currentBlockNumber - 5,
+        currentBlockNumber + 20,
+        false
+      ] // set 10 gd per block
+    );
+
+    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
+
+    let [userMintedRewardBeforeStake, userPendingRewardBeforeStake] =
+      await getUserMintedAndPendingRewards(
+        staker.address,
+        simpleStaking1.address
+      );
+    expect(userMintedRewardBeforeStake).to.eq("0");
+    expect(userPendingRewardBeforeStake).to.eq("0");
+
+    const stakingAmount = ethers.utils.parseEther("1000");
+    await dai["mint(address,uint256)"](staker.address, stakingAmount);
+    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
+    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
+    await advanceBlocks(5); //should accumulate some gdao rewards
+
+    const rewardsPerBlockBefore = await stakersDistribution.rewardsPerBlock(
+      simpleStaking1.address
+    );
+
+    // reduce rewarsd speed by half from 2m to 1m
+    let encoded = stakersDistribution.interface.encodeFunctionData(
+      "setMonthlyReputationDistribution",
+      [ethers.utils.parseEther("1000000")]
+    );
+    await genericCall(stakersDistribution.address, encoded);
+    const rewardsPerBlockAfter = await stakersDistribution.rewardsPerBlock(
+      simpleStaking1.address
+    );
+    let [userMintedRewardAfterStake, userPendingRewardAfterStake] =
+      await getUserMintedAndPendingRewards(
+        staker.address,
+        simpleStaking1.address
+      );
+    expect(userMintedRewardAfterStake).eq(0);
+    expect(userPendingRewardAfterStake).gt(0);
+
+    await advanceBlocks(4); //should accumulate some gdao rewards
+    let [userMintedRewardAfterUpdate, userPendingRewardAfterUpdate] =
+      await getUserMintedAndPendingRewards(
+        staker.address,
+        simpleStaking1.address
+      );
+    expect(userMintedRewardAfterUpdate).eq(0);
+    // rewards speed has been reduced by half,
+    expect(rewardsPerBlockAfter).lt(rewardsPerBlockBefore.mul(55).div(100));
+    // was forced 4 blocks to pass since reward update
+    expect(userPendingRewardAfterUpdate).eq(
+      userPendingRewardAfterStake.add(rewardsPerBlockAfter.mul(4))
+    );
+  });
 });

package/test/helpers.ts

@@ -301,6 +301,9 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
       kind: "uups"
     }
   );
+
+  console.log("deploying disthelper...");
+
   let distHelper = await upgrades.deployProxy(
     await ethers.getContractFactory("DistributionHelper"),
     [nameService.address],
@@ -438,6 +441,10 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
   await setDAOAddress("REPUTATION", reputation.address);
 
   console.log("setting reserve token...");
+  await cDAI["mint(address,uint256)"](
+    goodReserve.address,
+    10000
+  );
   await setReserveToken(
     cDAI.address,
     "100", //1gd

package/test/reserve/DistributionHelper.test.ts

@@ -195,7 +195,7 @@ describe("DistributionHelper", () => {
     expect(dr.transferType).to.equal(2);
   });
 
-  it("should distribute via fuse bridge", async () => {
+  it("should not distribute via fuse bridge", async () => {
     const { distHelper, bridge } = await loadFixture(fixture);
 
     const recipient = signers[0];
@@ -215,15 +215,15 @@ describe("DistributionHelper", () => {
     await genericCall(distHelper.address, encodedCall, avatar.address, 0);
 
     await goodDollar.mint(distHelper.address, "100000000000");
-    await distHelper.onDistribution("100000000000");
-    expect(await goodDollar.balanceOf(bridge.address)).to.equal(
-      (100000000000 * 2000) / 10000
-    );
-
-    const events = await bridge.queryFilter(bridge.filters.OnToken());
-    expect(events[0].args.sender).to.equal(distHelper.address);
-    expect(events[0].args.amount).to.equal((100000000000 * 2000) / 10000);
-    expect(events[0].args.data).to.equal(recipient.address.toLowerCase());
+    await expect(distHelper.onDistribution("100000000000")).revertedWith("DEPRECATED");
+    // expect(await goodDollar.balanceOf(bridge.address)).to.equal(
+    //   (100000000000 * 2000) / 10000
+    // );
+
+    // const events = await bridge.queryFilter(bridge.filters.OnToken());
+    // expect(events[0].args.sender).to.equal(distHelper.address);
+    // expect(events[0].args.amount).to.equal((100000000000 * 2000) / 10000);
+    // expect(events[0].args.data).to.equal(recipient.address.toLowerCase());
   });
 
   it("should distribute via layerzero bridge", async () => {

package/test/reserve/GoodMarketMaker.test.ts

@@ -120,6 +120,22 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     expect(onecDAIReturn.toNumber() / 100).to.be.equal(10000); //0.0001 cdai is 1 gd, so for 1eth you get 10000 gd (divide by 100 to account for 2 decimals precision)
   });
 
+  it("should calculate mint UBI correctly for 8 decimals precision when price is 0.0001 and 100% ratio", async () => {
+    const expansion = await initializeToken(
+      cdai,
+      "100", //1gd
+      "10000", //0.0001 cDai
+      "1000000" //100% rr
+    );
+    const gdPrice = await marketMaker.currentPrice(cdai);
+    const toMint = await marketMaker.calculateMintInterest(cdai, "100000000");
+    const expectedTotalMinted = 10 ** 8 / gdPrice.toNumber(); //1cdai divided by gd price;
+    expect(expectedTotalMinted).to.be.equal(10000); //1k GD since price is 0.0001 cdai for 1 gd
+    expect(toMint.toString()).to.be.equal(
+      (expectedTotalMinted * 100).toString()
+    ); //add 2 decimals precision
+  });
+
   it("should update reserve ratio by days passed", async () => {
     const expansion = await marketMaker.reserveRatioDailyExpansion();
     // 20% yearly. set up in the constructor
@@ -144,16 +160,6 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     ).to.be.equal("994511"); // 998777 * 0.999388834642296000000000000^7
   });
 
-  it("should calculate mint UBI correctly for 8 decimals precision", async () => {
-    const gdPrice = await marketMaker.currentPrice(cdai);
-    const toMint = await marketMaker.calculateMintInterest(cdai, "100000000");
-    const expectedTotalMinted = 10 ** 8 / gdPrice.toNumber(); //1cdai divided by gd price;
-    expect(expectedTotalMinted).to.be.equal(10000); //1k GD since price is 0.0001 cdai for 1 gd
-    expect(toMint.toString()).to.be.equal(
-      (expectedTotalMinted * 100).toString()
-    ); //add 2 decimals precision
-  });
-
   it("should not return a sell contribution if the given gd is less than the given contribution amount", async () => {
     let dai = await deployDAIMock();
 
@@ -181,13 +187,27 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
   });
 
   it("should be able to calculate and update bonding curve gd balance based on oncoming cDAI and the price stays the same", async () => {
-    const priceBefore = await marketMaker.currentPrice(cdai);
+    let priceBefore = await marketMaker.currentPrice(cdai);
     await marketMaker.mintInterest(cdai, BN.from(1e8));
+    let priceAfter = await marketMaker.currentPrice(cdai)
+
+    expect(priceAfter).gt(0)
+    expect(priceBefore).gt(0)
     expect(
       Math.floor(
-        (await marketMaker.currentPrice(cdai).then(_ => _.toNumber())) / 100
-      ).toString()
+        (priceAfter.toNumber() / 100)).toString()
     ).to.be.equal(Math.floor(priceBefore.toNumber() / 100).toString());
+
+
+    // very large amount of cdai
+    priceBefore = await marketMaker.currentPrice(cdai);
+    await marketMaker.mintInterest(cdai, ethers.utils.parseEther("1"));
+    priceAfter = await marketMaker.currentPrice(cdai)
+
+    console.log({ priceAfter, priceBefore })
+    expect(priceAfter).gt(0)
+    expect(priceBefore).gt(0)
+    expect(priceAfter).to.eq(priceBefore);
   });
 
   it("should not be able to mint interest by a non owner", async () => {
@@ -273,11 +293,12 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       "800000" //80% rr
     );
     const price = await marketMaker.currentPrice(dai);
-    expect(price.toString()).to.be.equal("100000000000000"); //1gd is equal 0.0001 dai = 1000000000000000 wei;
+    expect(price.toString()).to.be.equal(ethers.utils.parseEther("0.000125")); //1gd is equal 0.0001/1*0.8 = 0.000125
     const oneDAIReturn = await marketMaker.buyReturn(
       dai,
       ethers.utils.parseEther("1") //1Dai
     );
+
     //bancor formula to calcualte return
     //gd return = gdsupply * ((1+tokenamount/tokensupply)^rr -1)
     const expectedReturn = 1 * ((1 + 1 / 0.0001) ** 0.8 - 1);
@@ -292,16 +313,27 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       dai,
       ethers.utils.parseEther("1")
     );
-    const expectedTotalMinted = 10 ** 18 / gdPrice.toNumber();
-    // according to the sell formula the gd price should be 10^14 so 10^18 / 10^14 = 10^4
-    // Return = _reserveBalance * (1 - (1 - _sellAmount / _supply) ^ (1000000 / _reserveRatio))
-    expect(expectedTotalMinted).to.be.equal(10000);
+    let reserveToken = await marketMaker.reserveTokens(dai);
+
+    //we expect price to stay the same p = reserve/supply*RR
+    const newPrice = reserveToken.reserveSupply.add(ethers.utils.parseEther("1")).mul(1e8).div(reserveToken.gdSupply.add(toMint).mul(reserveToken.reserveRatio))
+    expect(newPrice).equal(gdPrice)
+
+    // the formula is amountToMint = reserveInterest * tokenSupply / reserveBalance
+    const expectedTotalMinted = 10 ** 18 * reserveToken.gdSupply.toNumber() / reserveToken.reserveSupply.toNumber()
+    expect(expectedTotalMinted).to.be.equal(1000000);
     expect(toMint.toString()).to.be.equal(
-      (expectedTotalMinted * 100).toString()
+      (expectedTotalMinted).toString()
     );
   });
 
   it("should calculate sell return with cDAI", async () => {
+    await initializeToken(
+      cdai,
+      "1000000000", //1gd
+      "100000000000", //0.0001 cDai
+      "900000" //80% rr
+    );
     const gDReturn = await marketMaker.sellReturn(
       cdai,
       10 //0.1 gd
@@ -515,19 +547,36 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
   });
 
   it("should calculate amount of gd to mint based on incoming cDAI without effecting bonding curve price", async () => {
-    const priceBefore = await marketMaker.currentPrice(dai);
-    const toMint = await marketMaker.calculateMintInterest(
+    await initializeToken(
       dai,
-      BN.from("1000000000000000000")
-    );
-    const totalMinted = 1e18 / priceBefore.toNumber();
-    expect(toMint.toString()).to.be.equal(
-      Math.floor(totalMinted * 100).toString()
+      6e11,
+      ethers.utils.parseEther("600000"),
+      5e5
     );
+
+    const priceBefore = await marketMaker.currentPrice(dai);
+
+    await marketMaker.mintInterest(dai, ethers.utils.parseEther("100"))
     const priceAfter = await marketMaker.currentPrice(dai);
     expect(priceBefore.toString()).to.be.equal(priceAfter.toString());
   });
 
+  it("should calculate amount of gd to mint based on incoming cDAI with small precision issue effecting bonding curve price in very low amounts", async () => {
+    await initializeToken(
+      dai,
+      600,
+      600000000,
+      5e5
+    );
+
+    const priceBefore = await marketMaker.currentPrice(dai);
+
+    await marketMaker.mintInterest(dai, 60000)
+    const priceAfter = await marketMaker.currentPrice(dai);
+    expect(priceBefore).equal(200000000)
+    expect(priceAfter).equal(200020000)
+  });
+
   it("should not change the reserve ratio when calculate how much decrease it for the reservetoken", async () => {
     let reserveTokenBefore = await marketMaker.reserveTokens(cdai);
     let reserveRatioBefore = reserveTokenBefore.reserveRatio;

package/test/staking/StakingRewards.test.ts

@@ -47,8 +47,10 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     genericCall,
     goodCompoundStakingFactory,
     goodCompoundStakingTestFactory,
+    runAsAvatarOnly,
     deployStaking;
 
+
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
@@ -67,9 +69,11 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       reserve,
       setReserveToken,
       genericCall: gc,
-      COMP
+      COMP,
+      runAsAvatarOnly: raao
     } = await loadFixture(createDAO);
 
+    runAsAvatarOnly = raao
     const cdaiFactory = await ethers.getContractFactory("cDAIMock");
     const cBatFactory = await ethers.getContractFactory("cBATMock");
     const goodFundManagerFactory = await ethers.getContractFactory(
@@ -447,6 +451,15 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     expect(gdBalancerAfterWithdraw).to.be.equal(gdBalanceBeforeWithdraw);
   });
 
+  it("shouldn't be able to collect interest when contract is not active", async () => {
+    const goodCompoundStaking2 = await deployStaking(null, null, "1728000");
+    await expect(
+      goodFundManager
+        .connect(staker)
+        .collectInterest([goodCompoundStaking2.address], true)
+    ).revertedWith(/not a dao contract/);
+  });
+
   // it("should set blacklisted false and mint rewards", async () => {
   //   const goodFundManagerFactory = await ethers.getContractFactory(
   //     "GoodFundManager"
@@ -1137,6 +1150,86 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     expect(sortedArrays[1][0]).to.be.equal(cDAI1.address);
   });
 
+  // needs to come before next test where we blacklist the goodcompoundstaking contract
+  it("should revert when colleced interest is not greater than gas cost when 2 months passed [ @skip-on-coverage ]", async () => {
+
+    // make sure expansion is very low 
+    await initializeToken(
+      cDAI.address,
+      "129966743722", //1gd
+      "499870173594", //0.0001 cDai
+      "1000000" //100% rr
+    );
+    await runAsAvatarOnly(
+      goodReserve,
+      "setReserveRatioDailyExpansion(uint256,uint256)",
+      ethers.utils.parseEther("999999999"),
+      ethers.utils.parseEther("1000000000")
+    );
+
+    const currentBlockNumber = await ethers.provider.getBlockNumber();
+    const currentBlock = await ethers.provider.getBlock(currentBlockNumber);
+
+    let encodedData = goodFundManager.interface.encodeFunctionData(
+      "setStakingReward",
+      [
+        "1000",
+        goodCompoundStaking.address,
+        0,
+        currentBlockNumber + 1000000,
+        false
+      ] // set 10 gd per block
+    );
+    await genericCall(goodFundManager.address, encodedData);
+    await ethers.provider.send("evm_setNextBlockTimestamp", [
+      currentBlock.timestamp + 5185020
+    ]);
+    await ethers.provider.send("evm_mine", []);
+    console.log(await goodFundManager.activeContracts(0));
+    await expect(
+      goodFundManager.collectInterest([goodCompoundStaking.address], false)
+    ).revertedWith(/< gas costs/);
+  });
+
+  it("should be able to mint ubi when 0 interest but ubi value > interestMultiplier*gas cost when 2 months passed [ @skip-on-coverage ]", async () => {
+
+    await initializeToken(
+      cDAI.address,
+      "129966743722", //1gd
+      "499870173594", //0.0001 cDai
+      "400000" //100% rr
+    );
+    await runAsAvatarOnly(
+      goodReserve,
+      "setReserveRatioDailyExpansion(uint256,uint256)",
+      ethers.utils.parseEther("999999999"),
+      ethers.utils.parseEther("1000000000")
+    );
+
+    const currentBlockNumber = await ethers.provider.getBlockNumber();
+    const currentBlock = await ethers.provider.getBlock(currentBlockNumber);
+
+    let encodedData = goodFundManager.interface.encodeFunctionData(
+      "setStakingReward",
+      [
+        "1000",
+        goodCompoundStaking.address,
+        0,
+        currentBlockNumber + 1000000,
+        false
+      ] // set 10 gd per block
+    );
+    await genericCall(goodFundManager.address, encodedData);
+    await ethers.provider.send("evm_setNextBlockTimestamp", [
+      currentBlock.timestamp + 5185020
+    ]);
+    await ethers.provider.send("evm_mine", []);
+    console.log(await goodFundManager.activeContracts(0));
+    await expect(
+      goodFundManager.collectInterest([goodCompoundStaking.address], false)
+    ).revertedWith(/< gas costs/);
+  });
+
   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"
@@ -1156,22 +1249,6 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
   });
 
-  it("collected interest should be greater than gas cost when 2 months passed", async () => {
-    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_mine", []);
-    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"
@@ -1512,13 +1589,13 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     );
     await bat
       .connect(staker)
-      ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
     await bat
       .connect(signers[0])
-      ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
     await bat
       .connect(signers[1])
-      ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
     const stakerOneStakeBlockNumber =
       (await ethers.provider.getBlockNumber()) + 1;
     await simpleStaking1["stake(uint256,uint256,bool)"](
@@ -1533,7 +1610,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       (await ethers.provider.getBlockNumber()) + 1;
     await simpleStaking1
       .connect(staker)
-      ["stake(uint256,uint256,bool)"](stakingAmount.div(5), "0", false);
+    ["stake(uint256,uint256,bool)"](stakingAmount.div(5), "0", false);
     const stakerTwoGdBalanceAfterStake = await goodDollar.balanceOf(
       staker.address
     );
@@ -1541,7 +1618,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       (await ethers.provider.getBlockNumber()) + 1;
     await simpleStaking1
       .connect(signers[0])
-      ["stake(uint256,uint256,bool)"](stakingAmount.div(4), "0", false);
+    ["stake(uint256,uint256,bool)"](stakingAmount.div(4), "0", false);
     const stakerThreeGdBalanceAfterStake = await goodDollar.balanceOf(
       signers[0].address
     );
@@ -1549,7 +1626,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       (await ethers.provider.getBlockNumber()) + 1;
     await simpleStaking1
       .connect(signers[1])
-      ["stake(uint256,uint256,bool)"](stakingAmount.div(10), "0", false);
+    ["stake(uint256,uint256,bool)"](stakingAmount.div(10), "0", false);
     const stakerFourGdBalanceAfterStake = await goodDollar.balanceOf(
       signers[1].address
     );
@@ -1561,21 +1638,21 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     );
     await simpleStaking1
       .connect(staker)
-      ["withdrawStake(uint256,bool)"](stakingAmount.div(5), false);
+    ["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);
+    ["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);
+    ["withdrawStake(uint256,bool)"](stakingAmount.div(10), false);
     const stakerFourGdBalanceAfterWithdraw = await goodDollar.balanceOf(
       signers[1].address
     );
@@ -1683,7 +1760,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     );
     await bat
       .connect(staker)
-      ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
+    ["approve(address,uint256)"](simpleStaking1.address, stakingAmount);
     await simpleStaking1["stake(uint256,uint256,bool)"](
       stakingAmount,
       "0",
@@ -1695,14 +1772,14 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     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
+    ["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);
+    ["withdrawStake(uint256,bool)"](stakingAmount.div(20), false);
     const stakerWithdrawBlockNumber = await ethers.provider.getBlockNumber();
     const stakerGdBalanceAfterWithdraw = await goodDollar.balanceOf(
       staker.address

package/test/utils/ProtocolUpgrade.test.ts

@@ -460,6 +460,7 @@ describe("ProtocolUpgrade - Upgrade old protocol contracts to new ones", () => {
       "ExchangeHelper",
       deployment["test-mainnet"].ExchangeHelper
     );
+    await exchangeHelper.setAddresses();
     await cDAI["mint(address,uint256)"](
       founder.address,
       ethers.utils.parseUnits("1000", 8)