@gooddollar/goodprotocol 2.0.12 → 2.0.14-beta.0

package/test/reserve/GoodReserveCDai.test.ts

@@ -58,14 +58,8 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     nameService = ns;
     runAsAvatarOnly = raao;
     await setDAOAddress("UNISWAP_ROUTER", signers[0].address);
-    const exchangeHelperFactory = await ethers.getContractFactory(
-      "ExchangeHelper"
-    );
-    exchangeHelper = await upgrades.deployProxy(
-      exchangeHelperFactory,
-      [nameService.address],
-      { kind: "uups" }
-    );
+    const exchangeHelperFactory = await ethers.getContractFactory("ExchangeHelper");
+    exchangeHelper = await upgrades.deployProxy(exchangeHelperFactory, [nameService.address], { kind: "uups" });
     await exchangeHelper.setAddresses();
     await setDAOAddress("EXCHANGE_HELPER", exchangeHelper.address);
     console.log("deployed dao", {
@@ -165,17 +159,11 @@ describe("GoodReserve - staking with cDAI mocks", () => {
 
     await increaseTime(24 * 60 * 60); //required for reserve ratio advance
     const er = await cDAI.exchangeRateStored();
-    const daiAmount = ethers.utils
-      .parseEther("0.1")
-      .mul(BN.from("10").pow(10))
-      .mul(er)
-      .div(BN.from("10").pow(28));
+    const daiAmount = ethers.utils.parseEther("0.1").mul(BN.from("10").pow(10)).mul(er).div(BN.from("10").pow(28));
 
     await dai["mint(address,uint256)"](goodReserve.address, daiAmount);
-    const tx = await (
-      await goodReserve.mintUBI(daiAmount, 0, cDAI.address)
-    ).wait();
-    const gdBalanceFund = await goodDollar.balanceOf(founder.address);
+    const tx = await (await goodReserve.mintUBI(daiAmount, 0, cDAI.address)).wait();
+    const gdBalanceFund = await goodDollar.balanceOf(await goodReserve.distributionHelper());
     const gdPriceAfter = await goodReserve["currentPrice()"]();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
@@ -183,32 +171,20 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     let rrAfter = reserveToken.reserveRatio;
     // expected that minted token will be added to the previous supply
     const mintEvent = tx.events.find(_ => _.event === "UBIMinted");
-    console.log(
-      gdPriceBefore.toNumber(),
-      supplyAfter.toNumber(),
-      supplyBefore.toNumber()
-    );
+    console.log(gdPriceBefore.toNumber(), supplyAfter.toNumber(), supplyBefore.toNumber());
     expect(supplyAfter).to.be.equal(
-      mintEvent.args.gdInterestMinted
-        .add(mintEvent.args.gdExpansionMinted)
-        .add(supplyBefore)
+      mintEvent.args.gdInterestMinted.add(mintEvent.args.gdExpansionMinted).add(supplyBefore)
     );
     // expected that the new reserve balance will include
     // the new 1e18 cdai which transferred
-    expect(reserveBalanceAfter).to.be.equal(
-      reserveBalanceBefore.add(BN.from("10").pow(17))
-    );
+    expect(reserveBalanceAfter).to.be.equal(reserveBalanceBefore.add(BN.from("10").pow(17)));
     // the new reserve ratio should be effected from the mintExpansion by:
     // the daily change that was set up in the constructor (999388834642296)
     // requires the time advance simulation above
     expect(rrAfter.toString()).to.be.equal("999388");
     // the price should be the same
     expect(gdPriceAfter).to.be.equal(gdPriceBefore);
-    expect(gdBalanceFund).to.be.equal(
-      mintEvent.args.gdInterestMinted
-        .add(mintEvent.args.gdExpansionMinted)
-        .toString()
-    );
+    expect(gdBalanceFund).to.be.equal(mintEvent.args.gdInterestMinted.add(mintEvent.args.gdExpansionMinted).toString());
   });
 
   it("should not mint UBI if the reserve is not cDAI", async () => {
@@ -224,10 +200,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
   it("should be able to buy gd with DAI", async () => {
     let daiAmount = ethers.utils.parseEther("100");
     const cdaiRateStored = await cDAI.exchangeRateStored();
-    let amount = daiAmount
-      .div(BigNumber.from(10).pow(10))
-      .mul(BigNumber.from(10).pow(28))
-      .div(cdaiRateStored);
+    let amount = daiAmount.div(BigNumber.from(10).pow(10)).mul(BigNumber.from(10).pow(28)).div(cdaiRateStored);
     await dai["mint(uint256)"](daiAmount);
     await dai.approve(exchangeHelper.address, daiAmount);
     expect(await nameService.getAddress("DAI")).to.be.equal(dai.address);
@@ -240,9 +213,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     const priceBefore = await goodReserve["currentPrice()"]();
 
-    let transaction = await (
-      await exchangeHelper.buy([dai.address], daiAmount, 0, 0, NULL_ADDRESS)
-    ).wait();
+    let transaction = await (await exchangeHelper.buy([dai.address], daiAmount, 0, 0, NULL_ADDRESS)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
@@ -251,21 +222,14 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const daiBalanceAfter = await dai.balanceOf(founder.address);
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     const priceAfter = await goodReserve["currentPrice()"]();
-    expect(
-      (cDAIBalanceReserveAfter - cDAIBalanceReserveBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(
-      reserveBalanceAfter.sub(reserveBalanceBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(
-      gdBalanceAfter.sub(gdBalanceBefore).toString()
-    );
+    expect((cDAIBalanceReserveAfter - cDAIBalanceReserveBefore).toString()).to.be.equal(amount.toString());
+    expect(reserveBalanceAfter.sub(reserveBalanceBefore).toString()).to.be.equal(amount.toString());
+    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(gdBalanceAfter.sub(gdBalanceBefore).toString());
     expect(rrAfter.toString()).to.be.equal(rrBefore.toString());
     expect(gdBalanceAfter.gt(gdBalanceBefore)).to.be.true;
     expect(daiBalanceBefore.gt(daiBalanceAfter)).to.be.true;
     expect(priceAfter.toString()).to.be.equal(priceBefore.toString());
-    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not.empty;
   });
 
   it("should be able to buy gd with cDAI through buy", async () => {
@@ -282,9 +246,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     const priceBefore = await goodReserve["currentPrice()"]();
     await cDAI.approve(exchangeHelper.address, amount);
-    let transaction = await (
-      await exchangeHelper.buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-    ).wait();
+    let transaction = await (await exchangeHelper.buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
@@ -293,21 +255,14 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceAfter = await cDAI.balanceOf(founder.address);
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     const priceAfter = await goodReserve["currentPrice()"]();
-    expect(
-      (cDAIBalanceReserveAfter - cDAIBalanceReserveBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(
-      reserveBalanceAfter.sub(reserveBalanceBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(
-      gdBalanceAfter.sub(gdBalanceBefore).toString()
-    );
+    expect((cDAIBalanceReserveAfter - cDAIBalanceReserveBefore).toString()).to.be.equal(amount.toString());
+    expect(reserveBalanceAfter.sub(reserveBalanceBefore).toString()).to.be.equal(amount.toString());
+    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(gdBalanceAfter.sub(gdBalanceBefore).toString());
     expect(rrAfter.toString()).to.be.equal(rrBefore.toString());
     expect(gdBalanceAfter.gt(gdBalanceBefore)).to.be.true;
     expect(cDAIBalanceBefore.gt(cDAIBalanceAfter)).to.be.true;
     expect(priceAfter.toString()).to.be.equal(priceBefore.toString());
-    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not.empty;
   });
 
   it("should be able to buy gd with cDAI", async () => {
@@ -324,9 +279,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     const priceBefore = await goodReserve["currentPrice()"]();
     await cDAI.approve(exchangeHelper.address, amount);
-    let transaction = await (
-      await exchangeHelper.buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-    ).wait();
+    let transaction = await (await exchangeHelper.buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
@@ -335,21 +288,14 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceAfter = await cDAI.balanceOf(founder.address);
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     const priceAfter = await goodReserve["currentPrice()"]();
-    expect(
-      (cDAIBalanceReserveAfter - cDAIBalanceReserveBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(
-      reserveBalanceAfter.sub(reserveBalanceBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(
-      gdBalanceAfter.sub(gdBalanceBefore).toString()
-    );
+    expect((cDAIBalanceReserveAfter - cDAIBalanceReserveBefore).toString()).to.be.equal(amount.toString());
+    expect(reserveBalanceAfter.sub(reserveBalanceBefore).toString()).to.be.equal(amount.toString());
+    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(gdBalanceAfter.sub(gdBalanceBefore).toString());
     expect(rrAfter.toString()).to.be.equal(rrBefore.toString());
     expect(gdBalanceAfter.gt(gdBalanceBefore)).to.be.true;
     expect(cDAIBalanceBefore.gt(cDAIBalanceAfter)).to.be.true;
     expect(priceAfter.toString()).to.be.equal(priceBefore.toString());
-    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not.empty;
   });
 
   it("should be able to buy gd with cDAI with generic amount of cdai tokens", async () => {
@@ -365,27 +311,18 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const gdBalanceBefore = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     await cDAI.approve(exchangeHelper.address, amount);
-    let transaction = await (
-      await exchangeHelper.buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-    ).wait();
+    let transaction = await (await exchangeHelper.buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
     const gdBalanceAfter = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     // actual cdai balance
-    expect(
-      cDAIBalanceReserveAfter.sub(cDAIBalanceReserveBefore).toString()
-    ).to.be.equal(amount.toString());
+    expect(cDAIBalanceReserveAfter.sub(cDAIBalanceReserveBefore).toString()).to.be.equal(amount.toString());
     // cdai balance according to the market maker
-    expect(
-      reserveBalanceAfter.sub(reserveBalanceBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(
-      gdBalanceAfter.sub(gdBalanceBefore).toString()
-    );
-    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not
-      .empty;
+    expect(reserveBalanceAfter.sub(reserveBalanceBefore).toString()).to.be.equal(amount.toString());
+    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(gdBalanceAfter.sub(gdBalanceBefore).toString());
+    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not.empty;
   });
 
   it("should be able to buy gd with other non initialized tokens beside cDAI", async () => {
@@ -399,9 +336,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
   it("should not be able to buy gd without cDAI allowance", async () => {
     let amount = 1e8;
     await cDAI.approve(exchangeHelper.address, "0");
-    let error = await exchangeHelper
-      .buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-      .catch(e => e);
+    let error = await exchangeHelper.buy([cDAI.address], amount, 0, 0, NULL_ADDRESS).catch(e => e);
     expect(error.message).to.have.string("ERC20: insufficient allowance");
   });
 
@@ -412,20 +347,14 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     await cDAI.approve(exchangeHelper.address, amount);
     const gdBalanceBefore = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceBefore = await cDAI.balanceOf(founder.address);
-    let error = await exchangeHelper
-      .buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-      .catch(e => e);
+    let error = await exchangeHelper.buy([cDAI.address], amount, 0, 0, NULL_ADDRESS).catch(e => e);
     const gdBalanceAfter = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceAfter = await cDAI.balanceOf(founder.address);
     expect(error.message).not.to.be.empty;
     expect(gdBalanceAfter.toString()).to.be.equal(gdBalanceBefore.toString());
-    expect(cDAIBalanceAfter.toString()).to.be.equal(
-      cDAIBalanceBefore.toString()
-    );
+    expect(cDAIBalanceAfter.toString()).to.be.equal(cDAIBalanceBefore.toString());
 
-    await cDAI
-      .connect(staker)
-      .transfer(founder.address, cDAIBalanceBeforeTransfer.toString());
+    await cDAI.connect(staker).transfer(founder.address, cDAIBalanceBeforeTransfer.toString());
   });
 
   it("should not be able to buy gd when the minimum return is higher than the actual return", async () => {
@@ -433,18 +362,12 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     await cDAI.approve(exchangeHelper.address, amount);
     const gdBalanceBefore = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceBefore = await cDAI.balanceOf(founder.address);
-    let error = await exchangeHelper
-      .buy([cDAI.address], amount, 2000000, 0, NULL_ADDRESS)
-      .catch(e => e);
+    let error = await exchangeHelper.buy([cDAI.address], amount, 2000000, 0, NULL_ADDRESS).catch(e => e);
     const gdBalanceAfter = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceAfter = await cDAI.balanceOf(founder.address);
-    expect(error.message).to.have.string(
-      "GD return must be above the minReturn"
-    );
+    expect(error.message).to.have.string("GD return must be above the minReturn");
     expect(gdBalanceAfter.toString()).to.be.equal(gdBalanceBefore.toString());
-    expect(cDAIBalanceAfter.toString()).to.be.equal(
-      cDAIBalanceBefore.toString()
-    );
+    expect(cDAIBalanceAfter.toString()).to.be.equal(cDAIBalanceBefore.toString());
   });
 
   it("should be able to sell gd to cDAI without contribution", async () => {
@@ -457,9 +380,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceBefore = await cDAI.balanceOf(founder.address);
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     await goodDollar.approve(exchangeHelper.address, amount);
-    let transaction = await (
-      await exchangeHelper.sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-    ).wait();
+    let transaction = await (await exchangeHelper.sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
@@ -468,10 +389,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     // according to the initialization settings reserve ratio is 100%. the calculation is:
     // Return = _reserveBalance * (1 - (1 - _sellAmount / _supply) ^ (1000000 / _reserveRatio))
-    const bancor = await ethers.getContractAt(
-      "BancorFormula",
-      await marketMaker.getBancor()
-    );
+    const bancor = await ethers.getContractAt("BancorFormula", await marketMaker.getBancor());
     const expectedReturn = await bancor.calculateSaleReturn(
       supplyBefore.toString(),
       reserveBalanceBefore.toString(),
@@ -479,18 +397,13 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       amount
     );
     expect(cDAIBalanceAfter - cDAIBalanceBefore).to.be.equal(expectedReturn);
-    expect(cDAIBalanceReserveBefore - cDAIBalanceReserveAfter).to.be.equal(
-      expectedReturn
-    );
-    expect(reserveBalanceBefore.sub(reserveBalanceAfter)).to.be.equal(
-      expectedReturn
-    );
+    expect(cDAIBalanceReserveBefore - cDAIBalanceReserveAfter).to.be.equal(expectedReturn);
+    expect(reserveBalanceBefore.sub(reserveBalanceAfter)).to.be.equal(expectedReturn);
     // 1e4 gd sold (burn from the supply)
     expect(supplyBefore.sub(supplyAfter)).to.be.equal(amount);
     expect(gdBalanceBefore.gt(gdBalanceAfter)).to.be.true;
     expect(cDAIBalanceAfter.gt(cDAIBalanceBefore)).to.be.true;
-    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not.empty;
   });
 
   it("should be able to sell gd to cDAI without contribution through sell function", async () => {
@@ -503,9 +416,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceBefore = await cDAI.balanceOf(founder.address);
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     await goodDollar.approve(exchangeHelper.address, amount);
-    let transaction = await (
-      await exchangeHelper.sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-    ).wait();
+    let transaction = await (await exchangeHelper.sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
@@ -514,10 +425,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     // according to the initialization settings reserve ratio is 100%. the calculation is:
     // Return = _reserveBalance * (1 - (1 - _sellAmount / _supply) ^ (1000000 / _reserveRatio))
-    const bancor = await ethers.getContractAt(
-      "BancorFormula",
-      await marketMaker.getBancor()
-    );
+    const bancor = await ethers.getContractAt("BancorFormula", await marketMaker.getBancor());
     const expectedReturn = await bancor.calculateSaleReturn(
       supplyBefore.toString(),
       reserveBalanceBefore.toString(),
@@ -525,18 +433,13 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       amount
     );
     expect(cDAIBalanceAfter - cDAIBalanceBefore).to.be.equal(expectedReturn);
-    expect(cDAIBalanceReserveBefore - cDAIBalanceReserveAfter).to.be.equal(
-      expectedReturn
-    );
-    expect(reserveBalanceBefore.sub(reserveBalanceAfter)).to.be.equal(
-      expectedReturn
-    );
+    expect(cDAIBalanceReserveBefore - cDAIBalanceReserveAfter).to.be.equal(expectedReturn);
+    expect(reserveBalanceBefore.sub(reserveBalanceAfter)).to.be.equal(expectedReturn);
     // 1e4 gd sold (burn from the supply)
     expect(supplyBefore.sub(supplyAfter)).to.be.equal(amount);
     expect(gdBalanceBefore.gt(gdBalanceAfter)).to.be.true;
     expect(cDAIBalanceAfter.gt(cDAIBalanceBefore)).to.be.true;
-    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not.empty;
   });
 
   it("should be able to sell gd to DAI without contribution through sell function", async () => {
@@ -549,9 +452,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const daiBalanceBefore = await dai.balanceOf(founder.address);
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     await goodDollar.approve(exchangeHelper.address, amount);
-    let transaction = await (
-      await exchangeHelper.sell([dai.address], amount, 0, 0, NULL_ADDRESS)
-    ).wait();
+    let transaction = await (await exchangeHelper.sell([dai.address], amount, 0, 0, NULL_ADDRESS)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
@@ -560,10 +461,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     // according to the initialization settings reserve ratio is 100%. the calculation is:
     // Return = _reserveBalance * (1 - (1 - _sellAmount / _supply) ^ (1000000 / _reserveRatio))
-    const bancor = await ethers.getContractAt(
-      "BancorFormula",
-      await marketMaker.getBancor()
-    );
+    const bancor = await ethers.getContractAt("BancorFormula", await marketMaker.getBancor());
     const expectedReturn = await bancor.calculateSaleReturn(
       supplyBefore.toString(),
       reserveBalanceBefore.toString(),
@@ -582,26 +480,15 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     //expect(supplyBefore.sub(supplyAfter)).to.be.equal(amount);
     //expect(gdBalanceBefore.gt(gdBalanceAfter)).to.be.true;
     expect(daiBalanceAfter.gt(daiBalanceBefore)).to.be.true;
-    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not.empty;
   });
 
   it("should set sell contribution ratio by avatar", async () => {
     let nom = ethers.utils.parseUnits("2", 14);
     let denom = ethers.utils.parseUnits("1", 15);
-    let ccFactory = await ethers.getContractFactory(
-      ContributionCalculation.abi,
-      ContributionCalculation.bytecode
-    );
-    let encodedCall = ccFactory.interface.encodeFunctionData(
-      "setContributionRatio",
-      [nom, denom]
-    );
-    const ctrl = await ethers.getContractAt(
-      "Controller",
-      controller,
-      schemeMock
-    );
+    let ccFactory = await ethers.getContractFactory(ContributionCalculation.abi, ContributionCalculation.bytecode);
+    let encodedCall = ccFactory.interface.encodeFunctionData("setContributionRatio", [nom, denom]);
+    const ctrl = await ethers.getContractAt("Controller", controller, schemeMock);
 
     await ctrl.genericCall(contribution.address, encodedCall, avatar, 0);
     const newRatio = await contribution.sellContributionRatio();
@@ -609,9 +496,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
   });
 
   it("should not be able to set the sell contribution ratio if not avatar", async () => {
-    let error = await contribution
-      .setContributionRatio(2e14, 1e15)
-      .catch(e => e);
+    let error = await contribution.setContributionRatio(2e14, 1e15).catch(e => e);
     expect(error.message).to.have.string("only Avatar can call this method");
   });
 
@@ -712,9 +597,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
 
     await goodDollar.connect(staker).approve(exchangeHelper.address, amount);
     let transaction = await (
-      await exchangeHelper
-        .connect(staker)
-        .sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)
+      await exchangeHelper.connect(staker).sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)
     ).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
@@ -724,25 +607,18 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceAfter = await cDAI.balanceOf(staker.address);
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     const priceAfter = await goodReserve["currentPrice()"]();
-    expect(cDAIBalanceAfter.sub(cDAIBalanceBefore)).to.be.equal(
-      expectedReturn,
-      "seller return mismatch"
-    );
+    expect(cDAIBalanceAfter.sub(cDAIBalanceBefore)).to.be.equal(expectedReturn, "seller return mismatch");
     expect(cDAIBalanceReserveBefore.sub(cDAIBalanceReserveAfter)).to.be.equal(
       expectedReturn,
       "reserve balance mismatch"
     );
-    expect(reserveBalanceBefore.sub(reserveBalanceAfter)).to.be.equal(
-      expectedReturn,
-      "reserve token data mismatch"
-    );
+    expect(reserveBalanceBefore.sub(reserveBalanceAfter)).to.be.equal(expectedReturn, "reserve token data mismatch");
     expect(supplyBefore.sub(supplyAfter)).to.be.equal(amount);
     expect(rrAfter.toString()).to.be.equal(rrBefore.toString());
     expect(gdBalanceBefore.gt(gdBalanceAfter)).to.be.true;
     expect(cDAIBalanceAfter.gt(cDAIBalanceBefore)).to.be.true;
     expect(priceAfter.toString()).to.be.equal(priceBefore.toString());
-    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not.empty;
   });
 
   it("should able to sell gd to DAI or cDAI token", async () => {
@@ -758,43 +634,30 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     await goodDollar.approve(exchangeHelper.address, "0");
     const gdBalanceBefore = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceBefore = await cDAI.balanceOf(founder.address);
-    let error = await exchangeHelper
-      .sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-      .catch(e => e);
+    let error = await exchangeHelper.sell([cDAI.address], amount, 0, 0, NULL_ADDRESS).catch(e => e);
     const gdBalanceAfter = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceAfter = await cDAI.balanceOf(founder.address);
     expect(error.message).not.to.be.empty;
     expect(gdBalanceAfter.toString()).to.be.equal(gdBalanceBefore.toString());
-    expect(cDAIBalanceAfter.toString()).to.be.equal(
-      cDAIBalanceBefore.toString()
-    );
+    expect(cDAIBalanceAfter.toString()).to.be.equal(cDAIBalanceBefore.toString());
   });
 
   it("should not be able to sell gd without enough gd funds", async () => {
     let amount = 1e4;
     const gdBalanceBeforeTransfer = await goodDollar.balanceOf(founder.address);
     //reset gd holdings
-    await goodDollar.transfer(
-      staker.address,
-      gdBalanceBeforeTransfer.toString()
-    );
+    await goodDollar.transfer(staker.address, gdBalanceBeforeTransfer.toString());
     await goodDollar.approve(exchangeHelper.address, amount);
     const gdBalanceBefore = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceBefore = await cDAI.balanceOf(founder.address);
-    let error = await exchangeHelper
-      .sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)
-      .catch(e => e);
+    let error = await exchangeHelper.sell([cDAI.address], amount, 0, 0, NULL_ADDRESS).catch(e => e);
     const gdBalanceAfter = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceAfter = await cDAI.balanceOf(founder.address);
     expect(error.message).not.to.be.empty;
     expect(gdBalanceAfter.toString()).to.be.equal(gdBalanceBefore.toString());
-    expect(cDAIBalanceAfter.toString()).to.be.equal(
-      cDAIBalanceBefore.toString()
-    );
+    expect(cDAIBalanceAfter.toString()).to.be.equal(cDAIBalanceBefore.toString());
     //restore gd holdings
-    await goodDollar
-      .connect(staker)
-      .transfer(founder.address, gdBalanceBeforeTransfer.toString());
+    await goodDollar.connect(staker).transfer(founder.address, gdBalanceBeforeTransfer.toString());
   });
 
   it("should not be able to sell gd when the minimum return is higher than the actual return", async () => {
@@ -802,18 +665,12 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     await goodDollar.approve(exchangeHelper.address, amount);
     const gdBalanceBefore = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceBefore = await cDAI.balanceOf(founder.address);
-    let error = await exchangeHelper
-      .sell([cDAI.address], amount, 2000000, 0, NULL_ADDRESS)
-      .catch(e => e);
+    let error = await exchangeHelper.sell([cDAI.address], amount, 2000000, 0, NULL_ADDRESS).catch(e => e);
     const gdBalanceAfter = await goodDollar.balanceOf(founder.address);
     const cDAIBalanceAfter = await cDAI.balanceOf(founder.address);
-    expect(error.message).to.have.string(
-      "Token return must be above the minReturn"
-    );
+    expect(error.message).to.have.string("Token return must be above the minReturn");
     expect(gdBalanceAfter.toString()).to.be.equal(gdBalanceBefore.toString());
-    expect(cDAIBalanceAfter.toString()).to.be.equal(
-      cDAIBalanceBefore.toString()
-    );
+    expect(cDAIBalanceAfter.toString()).to.be.equal(cDAIBalanceBefore.toString());
   });
 
   it("should return an error if non avatar account is trying to execute recover", async () => {
@@ -822,23 +679,14 @@ describe("GoodReserve - staking with cDAI mocks", () => {
   });
 
   it("should transfer funds when execute recover of token which the reserve has some balance", async () => {
-    await dai["mint(address,uint256)"](
-      goodReserve.address,
-      ethers.utils.parseEther("100")
-    );
+    await dai["mint(address,uint256)"](goodReserve.address, ethers.utils.parseEther("100"));
 
     let reserveBalance = await dai.balanceOf(goodReserve.address);
     const reserveFactory = await ethers.getContractFactory("GoodReserveCDai");
 
-    let encodedCall = reserveFactory.interface.encodeFunctionData("recover", [
-      dai.address
-    ]);
+    let encodedCall = reserveFactory.interface.encodeFunctionData("recover", [dai.address]);
 
-    const ctrl = await ethers.getContractAt(
-      "Controller",
-      controller,
-      schemeMock
-    );
+    const ctrl = await ethers.getContractAt("Controller", controller, schemeMock);
     await ctrl.genericCall(goodReserve.address, encodedCall, avatar, 0);
     let recoveredBalance = await dai.balanceOf(avatar);
     expect(recoveredBalance).to.be.equal(reserveBalance);
@@ -863,9 +711,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
-    expect(cDAIBalanceReserveAfter.sub(cDAIBalanceReserveBefore)).to.be.equal(
-      amount.toString()
-    );
+    expect(cDAIBalanceReserveAfter.sub(cDAIBalanceReserveBefore)).to.be.equal(amount.toString());
     expect(reserveBalanceAfter.sub(reserveBalanceBefore)).to.be.equal(amount);
   });
   it("should be able to buy gd with cDAI directly through reserve", async () => {
@@ -894,15 +740,11 @@ describe("GoodReserve - staking with cDAI mocks", () => {
   });
   it("should not be able to sell gd through reserve when there is no enough allowance", async () => {
     await goodDollar.approve(goodReserve.address, "0");
-    const tx = await goodReserve
-      .sell("100", 0, founder.address, staker.address)
-      .catch(e => e);
+    const tx = await goodReserve.sell("100", 0, founder.address, staker.address).catch(e => e);
     expect(tx.message).to.be.not.empty;
   });
   it("seller parameter should not matter if caller is not exchange helper", async () => {
-    const stakerGDBalanceBeforeSell = await goodDollar.balanceOf(
-      staker.address
-    );
+    const stakerGDBalanceBeforeSell = await goodDollar.balanceOf(staker.address);
     await goodDollar.approve(goodReserve.address, "100");
     await goodReserve.sell("100", 0, founder.address, staker.address);
     const stakerGDBalanceAfterSell = await goodDollar.balanceOf(staker.address);
@@ -948,9 +790,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     await goodDollar.connect(staker).approve(exchangeHelper.address, amount);
     const transaction = await (
-      await exchangeHelper
-        .connect(staker)
-        .sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)
+      await exchangeHelper.connect(staker).sell([cDAI.address], amount, 0, 0, NULL_ADDRESS)
     ).wait();
 
     const cDAIBalanceAfter = await cDAI.balanceOf(staker.address);
@@ -962,16 +802,12 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     // the contribution ratio is 20%
     let expected =
       parseInt(reserveBalance.toString()) *
-      (1 -
-        (1 - amount.toNumber() / parseInt(supply.toString())) **
-          (1000000 / reserveToken.reserveRatio));
+      (1 - (1 - amount.toNumber() / parseInt(supply.toString())) ** (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);
     expect(cDAIBalanceAfter.sub(cDAIBalanceBefore)).to.be.equal(expected);
-    expect(cDAIBalanceReserveBefore.sub(cDAIBalanceReserveAfter)).to.be.equal(
-      expected
-    );
+    expect(cDAIBalanceReserveBefore.sub(cDAIBalanceReserveAfter)).to.be.equal(expected);
   });
 
   it("should be able to buy gd with cDAI for some other address through buy", async () => {
@@ -988,9 +824,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     const priceBefore = await goodReserve["currentPrice()"]();
     await cDAI.approve(exchangeHelper.address, amount);
-    let transaction = await (
-      await exchangeHelper.buy([cDAI.address], amount, 0, 0, staker.address)
-    ).wait();
+    let transaction = await (await exchangeHelper.buy([cDAI.address], amount, 0, 0, staker.address)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
@@ -999,21 +833,14 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceAfter = await cDAI.balanceOf(founder.address);
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     const priceAfter = await goodReserve["currentPrice()"]();
-    expect(
-      (cDAIBalanceReserveAfter - cDAIBalanceReserveBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(
-      reserveBalanceAfter.sub(reserveBalanceBefore).toString()
-    ).to.be.equal(amount.toString());
-    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(
-      gdBalanceAfter.sub(gdBalanceBefore).toString()
-    );
+    expect((cDAIBalanceReserveAfter - cDAIBalanceReserveBefore).toString()).to.be.equal(amount.toString());
+    expect(reserveBalanceAfter.sub(reserveBalanceBefore).toString()).to.be.equal(amount.toString());
+    expect(supplyAfter.sub(supplyBefore).toString()).to.be.equal(gdBalanceAfter.sub(gdBalanceBefore).toString());
     expect(rrAfter.toString()).to.be.equal(rrBefore.toString());
     expect(gdBalanceAfter.gt(gdBalanceBefore)).to.be.true;
     expect(cDAIBalanceBefore.gt(cDAIBalanceAfter)).to.be.true;
     expect(priceAfter.toString()).to.be.equal(priceBefore.toString());
-    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenPurchased")).to.be.not.empty;
   });
 
   it("should be able to sell gd to cDAI without contribution through sell function for some other address", async () => {
@@ -1026,9 +853,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceBefore = await cDAI.balanceOf(staker.address);
     const cDAIBalanceReserveBefore = await cDAI.balanceOf(goodReserve.address);
     await goodDollar.approve(exchangeHelper.address, amount);
-    let transaction = await (
-      await exchangeHelper.sell([cDAI.address], amount, 0, 0, staker.address)
-    ).wait();
+    let transaction = await (await exchangeHelper.sell([cDAI.address], amount, 0, 0, staker.address)).wait();
     reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceAfter = reserveToken.reserveSupply;
     let supplyAfter = reserveToken.gdSupply;
@@ -1037,10 +862,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     const cDAIBalanceReserveAfter = await cDAI.balanceOf(goodReserve.address);
     // according to the initialization settings reserve ratio is 100%. the calculation is:
     // Return = _reserveBalance * (1 - (1 - _sellAmount / _supply) ^ (1000000 / _reserveRatio))
-    const bancor = await ethers.getContractAt(
-      "BancorFormula",
-      await marketMaker.getBancor()
-    );
+    const bancor = await ethers.getContractAt("BancorFormula", await marketMaker.getBancor());
     const expectedReturn = await bancor.calculateSaleReturn(
       supplyBefore.toString(),
       reserveBalanceBefore.toString(),
@@ -1048,18 +870,13 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       amount
     );
     expect(cDAIBalanceAfter - cDAIBalanceBefore).to.be.equal(expectedReturn);
-    expect(cDAIBalanceReserveBefore - cDAIBalanceReserveAfter).to.be.equal(
-      expectedReturn
-    );
-    expect(reserveBalanceBefore.sub(reserveBalanceAfter)).to.be.equal(
-      expectedReturn
-    );
+    expect(cDAIBalanceReserveBefore - cDAIBalanceReserveAfter).to.be.equal(expectedReturn);
+    expect(reserveBalanceBefore.sub(reserveBalanceAfter)).to.be.equal(expectedReturn);
     // 1e4 gd sold (burn from the supply)
     expect(supplyBefore.sub(supplyAfter)).to.be.equal(amount);
     expect(gdBalanceBefore.gt(gdBalanceAfter)).to.be.true;
     expect(cDAIBalanceAfter.gt(cDAIBalanceBefore)).to.be.true;
-    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not
-      .empty;
+    expect(transaction.events.find(_ => _.event === "TokenSold")).to.be.not.empty;
   });
 
   it("should be able to retain the precision when selling a low quantity of tokens", async () => {
@@ -1086,57 +903,36 @@ describe("GoodReserve - staking with cDAI mocks", () => {
 
     let encodedCall = reserveFactory.interface.encodeFunctionData("end");
 
-    const ctrl = await ethers.getContractAt(
-      "Controller",
-      controller,
-      schemeMock
-    );
+    const ctrl = await ethers.getContractAt("Controller", controller, schemeMock);
 
-    const tx = await (
-      await ctrl.genericCall(goodReserve.address, encodedCall, avatar, 0)
-    ).wait();
+    const tx = await (await ctrl.genericCall(goodReserve.address, encodedCall, avatar, 0)).wait();
 
     let avatarBalanceAfter = await cDAI.balanceOf(avatar);
     let reserveBalanceAfter = await cDAI.balanceOf(goodReserve.address);
 
-    expect(avatarBalanceAfter.sub(avatarBalanceBefore)).to.be.equal(
-      reserveBalanceBefore
-    );
+    expect(avatarBalanceAfter.sub(avatarBalanceBefore)).to.be.equal(reserveBalanceBefore);
     expect(reserveBalanceAfter.toString()).to.be.equal("0");
     expect(await goodDollar.isMinter(goodReserve.address)).to.be.false;
     expect(await goodDollar.isMinter(avatar)).to.be.true;
   });
 
   it("should set reserve ratio daily expansion by avatar", async () => {
-    let currentReserveRatioDailyExpansion =
-      await marketMaker.reserveRatioDailyExpansion();
+    let currentReserveRatioDailyExpansion = await marketMaker.reserveRatioDailyExpansion();
     console.log(currentReserveRatioDailyExpansion.toString());
 
-    await runAsAvatarOnly(
-      goodReserve,
-      "setReserveRatioDailyExpansion(uint256,uint256)",
-      1,
-      1e15
-    );
+    await runAsAvatarOnly(goodReserve, "setReserveRatioDailyExpansion(uint256,uint256)", 1, 1e15);
 
-    let newReserveRatioDailyExpansion =
-      await marketMaker.reserveRatioDailyExpansion();
+    let newReserveRatioDailyExpansion = await marketMaker.reserveRatioDailyExpansion();
     console.log(newReserveRatioDailyExpansion.toString());
 
-    expect(newReserveRatioDailyExpansion).to.not.equal(
-      currentReserveRatioDailyExpansion
-    );
+    expect(newReserveRatioDailyExpansion).to.not.equal(currentReserveRatioDailyExpansion);
     expect(newReserveRatioDailyExpansion).to.be.equal(BN.from("1000000000000"));
 
-    const encodedCall = goodReserve.interface.encodeFunctionData(
-      "setReserveRatioDailyExpansion",
-      [BN.from(currentReserveRatioDailyExpansion).div(1e12), 1e15]
-    );
-    const ctrl = await ethers.getContractAt(
-      "Controller",
-      controller,
-      schemeMock
-    );
+    const encodedCall = goodReserve.interface.encodeFunctionData("setReserveRatioDailyExpansion", [
+      BN.from(currentReserveRatioDailyExpansion).div(1e12),
+      1e15
+    ]);
+    const ctrl = await ethers.getContractAt("Controller", controller, schemeMock);
     await ctrl.genericCall(goodReserve.address, encodedCall, avatar, 0);
   });
 });