@gooddollar/goodprotocol 2.0.21 → 2.0.22-beta.0

package/test/utils/GoodDollarMintBurnWrapper.test.ts

@@ -1,7 +1,13 @@
-import { ethers, waffle, upgrades } from "hardhat";
+import { ethers, upgrades } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-import { GoodReserveCDai, GoodDollarMintBurnWrapper, ERC20, IGoodDollar, MultichainRouterMock } from "../../types";
+import {
+  GoodReserveCDai,
+  GoodDollarMintBurnWrapper,
+  ERC20,
+  IGoodDollar,
+  MultichainRouterMock
+} from "../../types";
 import { createDAO, increaseTime } from "../helpers";
 import { FormatTypes } from "@ethersproject/abi";
 
@@ -32,7 +38,16 @@ describe("GoodDollarMintBurnWrapper", () => {
     controller;
 
   before(async () => {
-    [founder, wrapperAdmin, minter, rewarder, guardian, minterUncapped, router, ...signers] = await ethers.getSigners();
+    [
+      founder,
+      wrapperAdmin,
+      minter,
+      rewarder,
+      guardian,
+      minterUncapped,
+      router,
+      ...signers
+    ] = await ethers.getSigners();
 
     let {
       controller: ctrl,
@@ -70,14 +85,11 @@ describe("GoodDollarMintBurnWrapper", () => {
     goodReserve = reserve as GoodReserveCDai;
   });
 
-  const fixture = async (wallets, provider) => {
-    wallets = provider.getWallets();
-
-    const gf = await ethers.getContractFactory("GoodDollarMintBurnWrapper");
+  const fixture = async () => {
     const ictrl = await ethers.getContractAt(
       "Controller",
       controller,
-      wallets[wallets.length - 1] //has scheme permissions set by createDAO()
+      signers[signers.length - 1] //has scheme permissions set by createDAO()
     );
 
     const wrapper = (await upgrades.deployProxy(
@@ -88,33 +100,57 @@ describe("GoodDollarMintBurnWrapper", () => {
       }
     )) as GoodDollarMintBurnWrapper;
 
-    await wrapper.connect(wrapperAdmin).grantRole(await wrapper.GUARDIAN_ROLE(), guardian.address);
+    await wrapper
+      .connect(wrapperAdmin)
+      .grantRole(await wrapper.GUARDIAN_ROLE(), guardian.address);
 
     await goodDollar.mint(controller, 10000000); //so bps limit is significant
 
     await wrapper
       .connect(wrapperAdmin)
-      .addMinter(router.address, MINTER_CAP, MINTER_TX_MAX, REWARD_BPS, MINTER_CAP, MINTER_TX_MAX, REWARD_BPS, false);
+      .addMinter(
+        router.address,
+        MINTER_CAP,
+        MINTER_TX_MAX,
+        REWARD_BPS,
+        MINTER_CAP,
+        MINTER_TX_MAX,
+        REWARD_BPS,
+        false
+      );
 
     await wrapper
       .connect(wrapperAdmin)
-      .addMinter(minter.address, MINTER_CAP, MINTER_TX_MAX, REWARD_BPS, MINTER_CAP, MINTER_TX_MAX, REWARD_BPS, false);
-    await wrapper.connect(wrapperAdmin).addMinter(rewarder.address, 0, 0, REWARD_BPS, 0, 0, 0, true);
+      .addMinter(
+        minter.address,
+        MINTER_CAP,
+        MINTER_TX_MAX,
+        REWARD_BPS,
+        MINTER_CAP,
+        MINTER_TX_MAX,
+        REWARD_BPS,
+        false
+      );
+    await wrapper
+      .connect(wrapperAdmin)
+      .addMinter(rewarder.address, 0, 0, REWARD_BPS, 0, 0, 0, true);
 
-    await ictrl.registerScheme(wrapper.address, ethers.constants.HashZero, "0x00000001", avatar);
+    await ictrl.registerScheme(
+      wrapper.address,
+      ethers.constants.HashZero,
+      "0x00000001",
+      avatar
+    );
     return { wrapper };
   };
 
-  const fixture_withMultichain = async (wallets, provider) => {
-    wallets = provider.getWallets();
-
-    const gf = await ethers.getContractFactory("GoodDollarMintBurnWrapper");
+  const fixture_withMultichain = async () => {
     const rf = await ethers.getContractFactory("MultichainRouterMock");
 
     const ictrl = await ethers.getContractAt(
       "Controller",
       controller,
-      wallets[wallets.length - 1] //has scheme permissions set by createDAO()
+      signers[signers.length - 1]
     );
 
     const wrapper = (await upgrades.deployProxy(
@@ -125,7 +161,9 @@ describe("GoodDollarMintBurnWrapper", () => {
       }
     )) as GoodDollarMintBurnWrapper;
 
-    const multiChainRouter = (await rf.deploy(wrapper.address)) as MultichainRouterMock;
+    const multiChainRouter = (await rf.deploy(
+      wrapper.address
+    )) as MultichainRouterMock;
 
     await wrapper
       .connect(wrapperAdmin)
@@ -160,20 +198,26 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should have avatar as default admin ", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     expect(await wrapper.owner()).to.equal(avatar);
-    expect(await wrapper.hasRole(await wrapper.DEFAULT_ADMIN_ROLE(), avatar)).to.be.true;
+    expect(await wrapper.hasRole(await wrapper.DEFAULT_ADMIN_ROLE(), avatar)).to
+      .be.true;
   });
 
   it("should have admin from params as default admin ", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    expect(await wrapper.hasRole(await wrapper.DEFAULT_ADMIN_ROLE(), wrapperAdmin.address)).to.be.true;
+    expect(
+      await wrapper.hasRole(
+        await wrapper.DEFAULT_ADMIN_ROLE(),
+        wrapperAdmin.address
+      )
+    ).to.be.true;
   });
 
   it("should have erc20 token info", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     expect(await wrapper.decimals()).to.equal(await goodDollar.decimals());
     expect(await wrapper.name()).to.equal("GoodDollar");
@@ -181,64 +225,93 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should update updateFrequency only by admin or guardian role", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     expect(await wrapper.updateFrequency()).to.equal(60 * 60 * 24 * 7); //default 90 days;
 
-    await expect(wrapper.setUpdateFrequency(0)).to.be.revertedWith("role");
-    await expect(wrapper.connect(wrapperAdmin).setUpdateFrequency(0)).to.not.reverted;
+    await expect(wrapper.setUpdateFrequency(0)).to.be.revertedWith(/role/);
+    await expect(wrapper.connect(wrapperAdmin).setUpdateFrequency(0)).to.not
+      .reverted;
     expect(await wrapper.updateFrequency()).to.equal(0);
-    await expect(wrapper.connect(guardian).setUpdateFrequency(1)).to.not.reverted;
+    await expect(wrapper.connect(guardian).setUpdateFrequency(1)).to.not
+      .reverted;
     expect(await wrapper.updateFrequency()).to.equal(1);
   });
 
   it("should be able to pause roles only by admin or guardian role", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.unpause(await wrapper.PAUSE_ALL_ROLE())).to.be.revertedWith("role");
+    await expect(
+      wrapper.unpause(await wrapper.PAUSE_ALL_ROLE())
+    ).to.be.revertedWith(/role/);
 
-    await expect(wrapper.connect(wrapperAdmin).pause(await wrapper.PAUSE_BURN_ROLE())).to.not.reverted;
-    await expect(wrapper.connect(guardian).pause(await wrapper.PAUSE_ALL_ROLE())).to.not.reverted;
+    await expect(
+      wrapper.connect(wrapperAdmin).pause(await wrapper.PAUSE_BURN_ROLE())
+    ).to.not.reverted;
+    await expect(
+      wrapper.connect(guardian).pause(await wrapper.PAUSE_ALL_ROLE())
+    ).to.not.reverted;
 
-    expect(await wrapper.paused(await wrapper.PAUSE_BURN_ROLE())).to.equal(true);
+    expect(await wrapper.paused(await wrapper.PAUSE_BURN_ROLE())).to.equal(
+      true
+    );
     expect(await wrapper.paused(await wrapper.PAUSE_ALL_ROLE())).to.equal(true);
   });
 
   it("should be able to unpause roles only by admin or guardian role", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.unpause(await wrapper.PAUSE_ALL_ROLE())).to.be.revertedWith("role");
+    await expect(
+      wrapper.unpause(await wrapper.PAUSE_ALL_ROLE())
+    ).to.be.revertedWith(/role/);
 
-    await expect(wrapper.connect(wrapperAdmin).pause(await wrapper.PAUSE_BURN_ROLE())).to.not.reverted;
+    await expect(
+      wrapper.connect(wrapperAdmin).pause(await wrapper.PAUSE_BURN_ROLE())
+    ).to.not.reverted;
 
-    await expect(wrapper.connect(wrapperAdmin).pause(await wrapper.PAUSE_ALL_ROLE())).to.not.reverted;
+    await expect(
+      wrapper.connect(wrapperAdmin).pause(await wrapper.PAUSE_ALL_ROLE())
+    ).to.not.reverted;
 
-    await expect(wrapper.connect(guardian).unpause(await wrapper.PAUSE_ALL_ROLE())).to.not.reverted;
+    await expect(
+      wrapper.connect(guardian).unpause(await wrapper.PAUSE_ALL_ROLE())
+    ).to.not.reverted;
 
-    await expect(wrapper.connect(wrapperAdmin).unpause(await wrapper.PAUSE_BURN_ROLE())).to.not.reverted;
+    await expect(
+      wrapper.connect(wrapperAdmin).unpause(await wrapper.PAUSE_BURN_ROLE())
+    ).to.not.reverted;
 
-    expect(await wrapper.paused(await wrapper.PAUSE_BURN_ROLE())).to.equal(false);
-    expect(await wrapper.paused(await wrapper.PAUSE_ALL_ROLE())).to.equal(false);
+    expect(await wrapper.paused(await wrapper.PAUSE_BURN_ROLE())).to.equal(
+      false
+    );
+    expect(await wrapper.paused(await wrapper.PAUSE_ALL_ROLE())).to.equal(
+      false
+    );
   });
 
   it("should be able to mint only by minter role", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.mint(founder.address, 1000)).to.revertedWith("role");
-    await expect(wrapper.connect(minter).mint(signers[0].address, 1000)).to.not.reverted;
+    await expect(wrapper.mint(founder.address, 1000)).to.revertedWith(/role/);
+    await expect(wrapper.connect(minter).mint(signers[0].address, 1000)).to.not
+      .reverted;
     expect(await goodDollar.balanceOf(signers[0].address)).to.equal(1000);
   });
 
   it("should not be able to mint when minter is paused", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.connect(guardian).pause(await wrapper.PAUSE_MINT_ROLE())).to.not.reverted;
+    await expect(
+      wrapper.connect(guardian).pause(await wrapper.PAUSE_MINT_ROLE())
+    ).to.not.reverted;
 
-    await expect(wrapper.connect(minter).mint(signers[0].address, 1000)).revertedWith("pause");
+    await expect(
+      wrapper.connect(minter).mint(signers[0].address, 1000)
+    ).revertedWith(/pause/);
   });
 
   it("should not be able to mint when passed daily cap", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     try {
       while (true) {
@@ -250,13 +323,15 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should not be able to mint when passed tx cap", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.connect(minter).mint(signers[0].address, MINTER_TX_MAX + 1)).revertedWith("max");
+    await expect(
+      wrapper.connect(minter).mint(signers[0].address, MINTER_TX_MAX + 1)
+    ).revertedWith(/max/);
   });
 
   it("should not be able to mint when passed minter cap", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     for (let i = 0; i < MINTER_CAP / MINTER_TX_MAX; i++) {
       if (i % 3 === 0) {
@@ -265,22 +340,30 @@ describe("GoodDollarMintBurnWrapper", () => {
       await wrapper.connect(minter).mint(signers[0].address, MINTER_TX_MAX);
     }
 
-    await expect(wrapper.connect(minter).mint(signers[0].address, MINTER_TX_MAX)).revertedWith("minter cap");
+    await expect(
+      wrapper.connect(minter).mint(signers[0].address, MINTER_TX_MAX)
+    ).revertedWith(/minter cap/);
   });
 
   xit("should not be able to mint when passed global cap", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await wrapper.connect(wrapperAdmin).addMinter(minterUncapped.address, 0, 10000000000, 0, 0, 0, 0, false);
+    await wrapper
+      .connect(wrapperAdmin)
+      .addMinter(minterUncapped.address, 0, 10000000000, 0, 0, 0, 0, false);
 
     for (let i = 0; i < 100000000000 / 10000000000; i++)
-      await wrapper.connect(minterUncapped).mint(signers[0].address, 10000000000);
+      await wrapper
+        .connect(minterUncapped)
+        .mint(signers[0].address, 10000000000);
 
-    await expect(wrapper.connect(minterUncapped).mint(signers[0].address, 10000000000)).revertedWith("total mint");
+    await expect(
+      wrapper.connect(minterUncapped).mint(signers[0].address, 10000000000)
+    ).revertedWith(/total mint/);
   });
 
   it("should not be able to burn when passed daily cap", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
     await goodDollar.mint(signers[0].address, 100000000);
     await goodDollar.connect(signers[0]).approve(wrapper.address, 100000000);
     try {
@@ -293,15 +376,17 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should not be able to burn when passed tx cap", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await goodDollar.mint(signers[0].address, 100000000);
     await goodDollar.connect(signers[0]).approve(wrapper.address, 100000000);
-    await expect(wrapper.connect(router).burn(signers[0].address, MINTER_TX_MAX + 1)).revertedWith("max");
+    await expect(
+      wrapper.connect(router).burn(signers[0].address, MINTER_TX_MAX + 1)
+    ).revertedWith(/max/);
   });
 
   it("should not be able to burn when passed minter cap", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
     await goodDollar.mint(signers[0].address, 100000000);
     await goodDollar.connect(signers[0]).approve(wrapper.address, 100000000);
 
@@ -312,11 +397,13 @@ describe("GoodDollarMintBurnWrapper", () => {
       await wrapper.connect(router).burn(signers[0].address, MINTER_TX_MAX);
     }
 
-    await expect(wrapper.connect(router).burn(signers[0].address, MINTER_TX_MAX)).revertedWith("minter cap");
+    await expect(
+      wrapper.connect(router).burn(signers[0].address, MINTER_TX_MAX)
+    ).revertedWith(/minter cap/);
   });
 
   it("should update stats after mint", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await wrapper.connect(minter).mint(signers[0].address, 1000);
 
@@ -333,32 +420,40 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should be able to burn only by minter role", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
     await goodDollar.mint(founder.address, 1000);
     await goodDollar.connect(founder).approve(wrapper.address, 1000);
-    await expect(wrapper.connect(guardian).burn(founder.address, 1000)).to.revertedWith("role");
-    await expect(wrapper.connect(router).burn(founder.address, 1000)).to.not.reverted;
+    await expect(
+      wrapper.connect(guardian).burn(founder.address, 1000)
+    ).to.revertedWith(/role/);
+    await expect(wrapper.connect(router).burn(founder.address, 1000)).to.not
+      .reverted;
 
     expect(await goodDollar.balanceOf(founder.address)).to.equal(0);
   });
 
   it("should not be able to burn when router is paused", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.connect(guardian).pause(await wrapper.PAUSE_ROUTER_ROLE())).to.not.reverted;
+    await expect(
+      wrapper.connect(guardian).pause(await wrapper.PAUSE_ROUTER_ROLE())
+    ).to.not.reverted;
 
     await goodDollar.mint(founder.address, 1000);
     await goodDollar.connect(founder).approve(wrapper.address, 1000);
 
-    await expect(wrapper.connect(router).burn(founder.address, 1000)).revertedWith("pause");
+    await expect(
+      wrapper.connect(router).burn(founder.address, 1000)
+    ).revertedWith(/pause/);
   });
 
   it("should not update stats after burn when not minted yet", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await goodDollar.mint(founder.address, 1000);
     await goodDollar.connect(founder).approve(wrapper.address, 1000);
-    await expect(wrapper.connect(router).burn(founder.address, 1000)).to.not.reverted;
+    await expect(wrapper.connect(router).burn(founder.address, 1000)).to.not
+      .reverted;
 
     expect(await wrapper.totalMinted()).eq(0);
 
@@ -367,13 +462,14 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should update global stats when minter!=burner after burn when already minted", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await wrapper.connect(minter).mint(signers[0].address, 1000);
 
     await goodDollar.mint(founder.address, 500);
     await goodDollar.connect(founder).approve(wrapper.address, 500);
-    await expect(wrapper.connect(router).burn(founder.address, 500)).to.not.reverted;
+    await expect(wrapper.connect(router).burn(founder.address, 500)).to.not
+      .reverted;
 
     expect(await wrapper.totalMinted()).eq(500);
 
@@ -382,14 +478,17 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should update both global and minter stats when minter==burner after burn when already minted", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await wrapper.connect(wrapperAdmin).grantRole(await wrapper.ROUTER_ROLE(), minter.address);
+    await wrapper
+      .connect(wrapperAdmin)
+      .grantRole(await wrapper.ROUTER_ROLE(), minter.address);
     await wrapper.connect(minter).mint(signers[0].address, 1000);
 
     await goodDollar.mint(founder.address, 500);
     await goodDollar.connect(founder).approve(wrapper.address, 500);
-    await expect(wrapper.connect(minter).burn(founder.address, 500)).to.not.reverted;
+    await expect(wrapper.connect(minter).burn(founder.address, 500)).to.not
+      .reverted;
 
     expect(await wrapper.totalMinted()).eq(500);
 
@@ -398,14 +497,17 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should reset minter total when burn amount > total", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await wrapper.connect(wrapperAdmin).grantRole(await wrapper.ROUTER_ROLE(), minter.address);
+    await wrapper
+      .connect(wrapperAdmin)
+      .grantRole(await wrapper.ROUTER_ROLE(), minter.address);
     await wrapper.connect(minter).mint(signers[0].address, 1000);
 
     await goodDollar.mint(founder.address, 2000);
     await goodDollar.connect(founder).approve(wrapper.address, 2000);
-    await expect(wrapper.connect(minter).burn(founder.address, 2000)).to.not.reverted;
+    await expect(wrapper.connect(minter).burn(founder.address, 2000)).to.not
+      .reverted;
 
     expect(await wrapper.totalMinted()).eq(0);
 
@@ -414,7 +516,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should update mint stats after sendOrMint", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await wrapper.connect(rewarder).sendOrMint(signers[0].address, 1000);
     const minterInfo = await wrapper.minterSupply(rewarder.address);
@@ -429,7 +531,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should not update mint stats after sendOrMint when wrapper has G$ balance", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await goodDollar.mint(wrapper.address, 1000);
 
@@ -446,7 +548,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should perform send and mint when having partial balance for sendOrMint", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await goodDollar.mint(wrapper.address, 500);
 
@@ -464,7 +566,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should reduce debt in sendOrMint", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await wrapper.connect(rewarder).sendOrMint(signers[0].address, 200); //200 debt
     const minterInfo = await wrapper.minterSupply(rewarder.address);
@@ -484,15 +586,19 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should mint just partial amount if daily limit passed in sendOrMint", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     let minterInfo = await wrapper.minterSupply(rewarder.address);
 
-    await wrapper.connect(rewarder).sendOrMint(signers[0].address, minterInfo.dailyCapIn.add(1000));
+    await wrapper
+      .connect(rewarder)
+      .sendOrMint(signers[0].address, minterInfo.dailyCapIn.add(1000));
 
     minterInfo = await wrapper.minterSupply(rewarder.address);
 
-    expect(await goodDollar.balanceOf(signers[0].address)).to.eq(minterInfo.dailyCapIn);
+    expect(await goodDollar.balanceOf(signers[0].address)).to.eq(
+      minterInfo.dailyCapIn
+    );
     expect(minterInfo.totalIn).eq(minterInfo.dailyCapIn);
     expect(minterInfo.totalRewards).eq(minterInfo.dailyCapIn);
     expect(minterInfo.mintedToday).eq(minterInfo.dailyCapIn);
@@ -502,7 +608,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should reset rewarder and minter mintedToday after day passed", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await wrapper.connect(rewarder).sendOrMint(signers[0].address, "1000");
 
@@ -510,9 +616,12 @@ describe("GoodDollarMintBurnWrapper", () => {
 
     await increaseTime(60 * 60 * 24);
 
-    await expect(wrapper.connect(rewarder).sendOrMint(signers[0].address, "1001")).to.not.reverted;
+    await expect(
+      wrapper.connect(rewarder).sendOrMint(signers[0].address, "1001")
+    ).to.not.reverted;
 
-    await expect(wrapper.connect(minter).mint(signers[0].address, "1001")).to.not.reverted;
+    await expect(wrapper.connect(minter).mint(signers[0].address, "1001")).to
+      .not.reverted;
 
     expect(await goodDollar.balanceOf(signers[0].address)).to.eq("4002");
     const minterInfo = await wrapper.minterSupply(rewarder.address);
@@ -521,7 +630,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should update rewarder daily limit after updateFrequency days passed", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     await goodDollar.mint(controller, 100000000000);
     const totalSupplyBeforeMint = await goodDollar.totalSupply();
@@ -530,21 +639,31 @@ describe("GoodDollarMintBurnWrapper", () => {
     const frequency = await wrapper.updateFrequency();
     await increaseTime(frequency.toNumber());
 
-    await wrapper.connect(rewarder).sendOrMint(signers[0].address, minterInfo.dailyCapIn.add(1000));
+    await wrapper
+      .connect(rewarder)
+      .sendOrMint(signers[0].address, minterInfo.dailyCapIn.add(1000));
 
     let minterInfoAfter = await wrapper.minterSupply(rewarder.address);
 
     expect(minterInfoAfter.dailyCapIn).gt(minterInfo.dailyCapIn);
-    expect(minterInfoAfter.dailyCapIn).eq(totalSupplyBeforeMint.mul(REWARD_BPS).div(10000)); //we doubled the G$ supply so bps relative to supply should be double now
+    expect(minterInfoAfter.dailyCapIn).eq(
+      totalSupplyBeforeMint.mul(REWARD_BPS).div(10000)
+    ); //we doubled the G$ supply so bps relative to supply should be double now
   });
 
   it("should not mint but not revert when rewarder passes daily limit", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
     const minterInfo = await wrapper.minterSupply(rewarder.address);
-    await wrapper.connect(rewarder).sendOrMint(signers[0].address, minterInfo.dailyCapIn);
+    await wrapper
+      .connect(rewarder)
+      .sendOrMint(signers[0].address, minterInfo.dailyCapIn);
 
-    const tx = await (await wrapper.connect(rewarder).sendOrMint(signers[1].address, minterInfo.dailyCapIn)).wait();
+    const tx = await (
+      await wrapper
+        .connect(rewarder)
+        .sendOrMint(signers[1].address, minterInfo.dailyCapIn)
+    ).wait();
 
     const sendOrMintEvent = tx.events.find(_ => _.event === "SendOrMint");
 
@@ -554,11 +673,17 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should allow guardian to update minter limits and rewarder daily limit", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.setMinterCaps(minter.address, 0, 0, 0, 0, 0, 0)).to.be.revertedWith("role");
+    await expect(
+      wrapper.setMinterCaps(minter.address, 0, 0, 0, 0, 0, 0)
+    ).to.be.revertedWith(/role/);
 
-    await expect(wrapper.connect(guardian).setMinterCaps(minter.address, 0, 0, 50, 0, 0, 60)).to.not.reverted;
+    await expect(
+      wrapper
+        .connect(guardian)
+        .setMinterCaps(minter.address, 0, 0, 50, 0, 0, 60)
+    ).to.not.reverted;
 
     const minterInfo = await wrapper.minterSupply(minter.address);
     const minterOutLimits = await wrapper.minterOutLimits(minter.address);
@@ -569,14 +694,18 @@ describe("GoodDollarMintBurnWrapper", () => {
     expect(minterOutLimits.capOut).to.eq(0);
     expect(minterOutLimits.maxOut).to.eq(0);
     expect(minterOutLimits.bpsPerDayOut).to.eq(60);
-    expect(minterInfo.dailyCapIn).eq((await goodDollar.totalSupply()).mul(50).div(10000));
-    expect(minterOutLimits.dailyCapOut).eq((await goodDollar.totalSupply()).mul(60).div(10000));
+    expect(minterInfo.dailyCapIn).eq(
+      (await goodDollar.totalSupply()).mul(50).div(10000)
+    );
+    expect(minterOutLimits.dailyCapOut).eq(
+      (await goodDollar.totalSupply()).mul(60).div(10000)
+    );
   });
 
   xit("should allow guardian to update totalMintCap", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.setTotalMintCap(0)).to.be.revertedWith("role");
+    await expect(wrapper.setTotalMintCap(0)).to.be.revertedWith(/role/);
 
     await expect(wrapper.connect(guardian).setTotalMintCap(0)).to.not.reverted;
 
@@ -584,56 +713,79 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should support transferAndCall for multichain bridge transfer", async () => {
-    const { wrapper, multiChainRouter } = await waffle.loadFixture(fixture_withMultichain);
+    const { wrapper, multiChainRouter } = await loadFixture(
+      fixture_withMultichain
+    );
 
     await goodDollar.mint(founder.address, 100000);
     await goodDollar.transferAndCall(
       wrapper.address,
       100000,
-      ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [minter.address, "4220"])
+      ethers.utils.defaultAbiCoder.encode(
+        ["address", "uint256"],
+        [minter.address, "4220"]
+      )
     );
 
     expect(await goodDollar.balanceOf(founder.address)).to.eq(0); //verify burn happened
     expect(await goodDollar.balanceOf(wrapper.address)).to.eq(0); //verify burn happened
-    const events = await multiChainRouter.queryFilter(multiChainRouter.filters.AnySwap());
+    const events = await multiChainRouter.queryFilter(
+      multiChainRouter.filters.AnySwap()
+    );
     expect(events[0].args.recipient).to.equal(minter.address);
     expect(events[0].args.chainId).to.equal(4220);
   });
 
   it("should default to sender as recipient on transferAndCall if recipient=0", async () => {
-    const { wrapper, multiChainRouter } = await waffle.loadFixture(fixture_withMultichain);
+    const { wrapper, multiChainRouter } = await loadFixture(
+      fixture_withMultichain
+    );
 
     await goodDollar.mint(founder.address, 100000);
     await goodDollar.transferAndCall(
       wrapper.address,
       100000,
-      ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [ethers.constants.AddressZero, "4220"])
+      ethers.utils.defaultAbiCoder.encode(
+        ["address", "uint256"],
+        [ethers.constants.AddressZero, "4220"]
+      )
     );
 
     expect(await goodDollar.balanceOf(founder.address)).to.eq(0); //verify burn happened
     expect(await goodDollar.balanceOf(wrapper.address)).to.eq(0); //verify burn happened
-    const events = await multiChainRouter.queryFilter(multiChainRouter.filters.AnySwap());
+    const events = await multiChainRouter.queryFilter(
+      multiChainRouter.filters.AnySwap()
+    );
     expect(events[0].args.recipient).to.equal(founder.address);
     expect(events[0].args.chainId).to.equal(4220);
   });
 
   it("should fail transferAndCall for multichain if no chainid", async () => {
-    const { wrapper, multiChainRouter } = await waffle.loadFixture(fixture_withMultichain);
+    const { wrapper, multiChainRouter } = await loadFixture(
+      fixture_withMultichain
+    );
 
     await goodDollar.mint(founder.address, 100000);
     await expect(
       goodDollar.transferAndCall(
         wrapper.address,
         100000,
-        ethers.utils.defaultAbiCoder.encode(["address", "uint"], [minter.address, 0])
+        ethers.utils.defaultAbiCoder.encode(
+          ["address", "uint"],
+          [minter.address, 0]
+        )
       )
-    ).revertedWith("chainId");
+    ).revertedWith(/chainId/);
   });
 
   it("should not mint or sendOrMint to self", async () => {
-    const { wrapper } = await waffle.loadFixture(fixture);
+    const { wrapper } = await loadFixture(fixture);
 
-    await expect(wrapper.connect(minter).mint(wrapper.address, 1)).revertedWith("self");
-    await expect(wrapper.connect(rewarder).sendOrMint(wrapper.address, 1)).revertedWith("self");
+    await expect(wrapper.connect(minter).mint(wrapper.address, 1)).revertedWith(
+      /self/
+    );
+    await expect(
+      wrapper.connect(rewarder).sendOrMint(wrapper.address, 1)
+    ).revertedWith(/self/);
   });
 });