@gooddollar/goodprotocol 2.0.25-beta.0 → 2.0.25-beta.10

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/reserve/GoodReserveCDai.test.ts

@@ -474,6 +474,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       "BancorFormula",
       await marketMaker.getBancor()
     );
+
     const expectedReturn = await bancor.calculateSaleReturn(
       supplyBefore.toString(),
       reserveBalanceBefore.toString(),
@@ -966,7 +967,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       parseInt(reserveBalance.toString()) *
       (1 -
         (1 - amount.toNumber() / parseInt(supply.toString())) **
-          (1000000 / reserveToken.reserveRatio));
+        (1000000 / reserveToken.reserveRatio));
 
     expected = Math.ceil((0.8 * expected) / 100) * 100; //deduct 20% contribution, allow 5 points precission mismatch (due to bancor pow estimation?), match solidity no floating point
     //expected = Math.floor(0.8 * expected);

package/test/staking/FuseStaking.test.ts

@@ -12,12 +12,7 @@ describe("FuseStakingV3", () => {
   let founder, staker1, staker2;
   let signers;
 
-  let uniswap: waffle.MockContract,
-    uniswapFactory,
-    uniswapPair,
-    gdusdcPair,
-    fusefusdPair,
-    ubiMock;
+  let uniswap: waffle.MockContract, uniswapFactory, uniswapPair, gdusdcPair, fusefusdPair, ubiMock;
 
   const deployMocks = async () => {
     let u = await hre.artifacts.readArtifact("Uniswap");
@@ -35,24 +30,14 @@ describe("FuseStakingV3", () => {
     await uniswap.mock.WETH.returns(signers[3].address);
     await uniswapFactory.mock.getPair.returns(uniswapPair.address);
     await uniswapFactory.mock.getPair
-      .withArgs(
-        ethers.constants.AddressZero,
-        "0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5"
-      )
+      .withArgs(ethers.constants.AddressZero, "0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5")
       .returns(gdusdcPair.address);
 
     await uniswapFactory.mock.getPair
-      .withArgs(
-        signers[3].address,
-        "0x249BE57637D8B013Ad64785404b24aeBaE9B098B"
-      )
+      .withArgs(signers[3].address, "0x249BE57637D8B013Ad64785404b24aeBaE9B098B")
       .returns(fusefusdPair.address);
 
-    await uniswapPair.mock.getReserves.returns(
-      ethers.utils.parseEther("1000"),
-      "100000",
-      "0"
-    );
+    await uniswapPair.mock.getReserves.returns(ethers.utils.parseEther("1000"), "100000", "0");
     await gdusdcPair.mock.getReserves.returns("4984886100", "10789000000", "0");
     await fusefusdPair.mock.getReserves.returns(
       ethers.utils.parseEther("10000"),
@@ -67,9 +52,7 @@ describe("FuseStakingV3", () => {
     await deployMocks();
 
     let network = networkConfig.name;
-    staking = (await (
-      await ethers.getContractFactory("FuseStakingV3")
-    ).deploy()) as FuseStakingV3;
+    staking = (await (await ethers.getContractFactory("FuseStakingV3")).deploy()) as FuseStakingV3;
 
     await staking.initialize(uniswap.address, NULL_ADDRESS);
     await staking.setUBIScheme(ubiMock.address);
@@ -80,54 +63,42 @@ describe("FuseStakingV3", () => {
   });
 
   it("should calc quantity with slippage", async () => {
-    const res = await staking[
-      "calcMaxTokenWithPriceImpact(uint256,uint256,uint256)"
-    ]("6917100025787759640000", "265724494", ethers.utils.parseEther("500"));
+    const res = await staking["calcMaxTokenWithPriceImpact(uint256,uint256,uint256)"](
+      "6917100025787759640000",
+      "265724494",
+      ethers.utils.parseEther("500")
+    );
 
     // const fuseQuantity = ethers.utils.formatEther(res);
     expect(res.maxToken).to.gt(0);
-    expect(res.maxToken).to.equal(
-      BigNumber.from("6917100025787759640000").mul(3).div(100)
-    );
-    expect(res.tokenOut).to.equal(7717004);
+    expect(res.maxToken).to.equal(BigNumber.from("6917100025787759640000").mul(6).div(1000));
+    expect(res.tokenOut).to.equal(1580111);
   });
 
   it("should calc quantity with uniswap mock", async () => {
-    const res = await staking["calcMaxFuseWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("500")
-    );
+    const res = await staking["calcMaxFuseWithPriceImpact(uint256)"](ethers.utils.parseEther("500"));
 
     // const fuseQuantity = ethers.utils.formatEther(res);
     expect(res.fuseAmount).to.gt(0);
-    expect(res.fuseAmount).to.equal(ethers.utils.parseEther("30"));
+    expect(res.fuseAmount).to.equal(ethers.utils.parseEther("6"));
 
-    await uniswapPair.mock.getReserves.returns(
-      ethers.utils.parseEther("100"),
-      "500000",
-      "0"
-    );
-    const res2 = await staking["calcMaxFuseWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("500")
-    );
+    await uniswapPair.mock.getReserves.returns(ethers.utils.parseEther("100"), "500000", "0");
+    const res2 = await staking["calcMaxFuseWithPriceImpact(uint256)"](ethers.utils.parseEther("500"));
 
-    expect(res2.fuseAmount).to.equal(ethers.utils.parseEther("3"));
+    expect(res2.fuseAmount).to.equal(ethers.utils.parseEther("0.6"));
   });
 
   it("should calculate gd/usdc quantity with 0 price impact ", async () => {
-    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("10")
-    );
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](ethers.utils.parseEther("10"));
     //exchanging 10 fuse which are equal 2$ USDC should have no significant price impact on usdc/gd swap so we should be able to swap the whole 10
     expect(res.maxFuse).to.gt(0);
     expect(res.maxFuse).to.equal(ethers.utils.parseEther("10"));
   });
 
   it("should detect gd/usdc price impact", async () => {
-    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("10000")
-    );
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](ethers.utils.parseEther("10000"));
     expect(res.maxFuse).to.lt(ethers.utils.parseEther("10000"));
-    expect(res.maxFuse).to.equal(ethers.utils.parseEther("1618.35")); //on fuse swap it was around 335$ on above gd/usdc reserves that reaches 3% impact, that means 335*5=1675fuse
+    expect(res.maxFuse).to.equal(ethers.utils.parseEther("323.67")); //on fuse swap it was around 335$ on above gd/usdc reserves that reaches 3% impact, that means 335*5=1675fuse
   });
 
   it("should match fuseswap and allow to exchange +-4600 fuse to G$", async () => {
@@ -141,10 +112,8 @@ describe("FuseStakingV3", () => {
       "0"
     );
 
-    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("10000")
-    );
-    expect(res.maxFuse).to.lt(ethers.utils.parseEther("5000"));
-    expect(res.maxFuse).to.gt(ethers.utils.parseEther("4500"));
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](ethers.utils.parseEther("10000"));
+    expect(res.maxFuse).to.lt(ethers.utils.parseEther("1000"));
+    expect(res.maxFuse).to.gt(ethers.utils.parseEther("450"));
   });
 });

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)

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es2018",
+    "target": "ESNext",
     "module": "commonjs",
     "strict": false,
     "moduleResolution": "node",