@gooddollar/goodprotocol 2.0.3-beta.0 → 2.0.3

package/test/utils/GoodDollarMintBurnWrapper.test.ts

@@ -1,13 +1,7 @@
 import { ethers, waffle, 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";
 
@@ -38,16 +32,7 @@ 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,
@@ -103,47 +88,20 @@ 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 };
   };
 
@@ -167,9 +125,7 @@ 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)
@@ -207,19 +163,13 @@ describe("GoodDollarMintBurnWrapper", () => {
     const { wrapper } = await waffle.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);
 
-    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 () => {
@@ -233,87 +183,58 @@ describe("GoodDollarMintBurnWrapper", () => {
   it("should update updateFrequency only by admin or guardian role", async () => {
     const { wrapper } = await waffle.loadFixture(fixture);
 
-    expect(await wrapper.updateFrequency()).to.equal(60 * 60 * 24 * 90); //default 90 days;
+    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.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);
 
-    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);
 
-    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);
 
     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.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);
 
-    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 () => {
@@ -331,9 +252,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   it("should not be able to mint when passed tx cap", async () => {
     const { wrapper } = await waffle.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 () => {
@@ -346,26 +265,18 @@ 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);
 
-    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 () => {
@@ -386,9 +297,7 @@ describe("GoodDollarMintBurnWrapper", () => {
 
     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 () => {
@@ -403,9 +312,7 @@ 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 () => {
@@ -429,11 +336,8 @@ describe("GoodDollarMintBurnWrapper", () => {
     const { wrapper } = await waffle.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);
   });
@@ -441,16 +345,12 @@ describe("GoodDollarMintBurnWrapper", () => {
   it("should not be able to burn when router is paused", async () => {
     const { wrapper } = await waffle.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 () => {
@@ -458,8 +358,7 @@ describe("GoodDollarMintBurnWrapper", () => {
 
     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);
 
@@ -474,8 +373,7 @@ describe("GoodDollarMintBurnWrapper", () => {
 
     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);
 
@@ -486,15 +384,12 @@ 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);
 
-    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);
 
@@ -505,15 +400,12 @@ describe("GoodDollarMintBurnWrapper", () => {
   it("should reset minter total when burn amount > total", async () => {
     const { wrapper } = await waffle.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);
 
@@ -596,15 +488,11 @@ describe("GoodDollarMintBurnWrapper", () => {
 
     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);
@@ -622,12 +510,9 @@ 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);
@@ -645,31 +530,21 @@ 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 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");
 
@@ -681,15 +556,9 @@ describe("GoodDollarMintBurnWrapper", () => {
   it("should allow guardian to update minter limits and rewarder daily limit", async () => {
     const { wrapper } = await waffle.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);
@@ -700,12 +569,8 @@ 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 () => {
@@ -719,67 +584,48 @@ describe("GoodDollarMintBurnWrapper", () => {
   });
 
   it("should support transferAndCall for multichain bridge transfer", async () => {
-    const { wrapper, multiChainRouter } = await waffle.loadFixture(
-      fixture_withMultichain
-    );
+    const { wrapper, multiChainRouter } = await waffle.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 waffle.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 waffle.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");
   });
@@ -787,11 +633,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   it("should not mint or sendOrMint to self", async () => {
     const { wrapper } = await waffle.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");
   });
 });