@gooddollar/goodprotocol 2.0.21 → 2.0.22-beta.0

package/test/reserve/GoodReserveCDai.cap.test.ts

@@ -66,7 +66,7 @@ describe("GoodReserve - Enforce token cap", () => {
   it("should not be able to mint if not minter", async () => {
     await expect(
       goodReserve.mintRewardFromRR(cDai, founder.address, 10)
-    ).to.be.revertedWith("GoodReserve: not a minter");
+    ).to.be.revertedWith(/GoodReserve: not a minter/);
   });
 
   it("should be able to mint if fund_manager contract and Reserve is minter", async () => {
@@ -136,7 +136,7 @@ describe("GoodReserve - Enforce token cap", () => {
 
     await expect(
       goodReserve.connect(founder).mintRewardFromRR(cDai, founder.address, 10)
-    ).to.be.revertedWith("GoodReserve: not a minter");
+    ).to.be.revertedWith(/GoodReserve: not a minter/);
   });
 
   it("should not be able to grant minter role if not Avatar", async () => {
@@ -145,7 +145,7 @@ describe("GoodReserve - Enforce token cap", () => {
         await goodReserve.RESERVE_MINTER_ROLE(),
         granted.address
       )
-    ).to.be.revertedWith("is missing role");
+    ).to.be.revertedWith(/is missing role/);
   });
 
   it("should be able to grant minter role if Avatar", async () => {
@@ -180,7 +180,7 @@ describe("GoodReserve - Enforce token cap", () => {
       goodReserve
         .connect(granted)
         .mintRewardFromRR(cDai, founder.address, 22 * 1e14)
-    ).to.be.revertedWith("GoodReserve: cap enforced");
+    ).to.be.revertedWith(/GoodReserve: cap enforced/);
   });
 
   it("should be able to revoke minter role if Avatar", async () => {

package/test/reserve/GoodReserveCDai.distribution.test.ts

@@ -1,4 +1,4 @@
-import { ethers, waffle } from "hardhat";
+import { ethers } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GoodReserveCDai, DistributionHelper } from "../../types";
@@ -12,7 +12,14 @@ export const BLOCK_INTERVAL = 1;
 
 describe("GoodReserve - Distribution Helper", () => {
   let goodReserve: GoodReserveCDai;
-  let goodDollar: Contract, genericCall, avatar, founder, signers, setDAOAddress, nameService, cDai;
+  let goodDollar: Contract,
+    genericCall,
+    avatar,
+    founder,
+    signers,
+    setDAOAddress,
+    nameService,
+    cDai;
 
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
@@ -54,45 +61,42 @@ describe("GoodReserve - Distribution Helper", () => {
     console.log("setting permissions...");
   });
 
-  const fixture = async (wallets, provider) => {
-    const df = await ethers.getContractFactory("DistributionHelper");
-    wallets = provider.getWallets();
-    const distHelper = (await waffle.deployContract(wallets[0], {
-      abi: JSON.parse(df.interface.format(FormatTypes.json) as string) as any[],
-      bytecode: df.bytecode
-    })) as DistributionHelper;
+  const fixture = async () => {
+    const distHelper = (await ethers.deployContract(
+      "DistributionHelper"
+    )) as DistributionHelper;
 
     return { distHelper };
   };
 
-  const deployed_fixture = async (wallets, provider) => {
-    const df = await ethers.getContractFactory("DistributionHelper");
-    wallets = provider.getWallets();
-    const distHelper = (await waffle.deployContract(wallets[0], {
-      abi: JSON.parse(df.interface.format(FormatTypes.json) as string) as any[],
-      bytecode: df.bytecode
-    })) as DistributionHelper;
+  const deployed_fixture = async () => {
+    const distHelper = (await ethers.deployContract(
+      "DistributionHelper"
+    )) as DistributionHelper;
 
     await distHelper.initialize(nameService.address);
 
-    const encodedCall = goodReserve.interface.encodeFunctionData("setDistributionHelper", [distHelper.address]);
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [distHelper.address]
+    );
 
     await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
 
     return { distHelper };
   };
 
-  const deployed_revert_fixture = async (wallets, provider) => {
-    const df = await ethers.getContractFactory("DistributionHelperTest");
-    wallets = provider.getWallets();
-    const distHelper = (await waffle.deployContract(wallets[0], {
-      abi: JSON.parse(df.interface.format(FormatTypes.json) as string) as any[],
-      bytecode: df.bytecode
-    })) as DistributionHelper;
+  const deployed_revert_fixture = async () => {
+    const distHelper = (await ethers.deployContract(
+      "DistributionHelperTest"
+    )) as DistributionHelper;
 
     await distHelper.initialize(nameService.address);
 
-    const encodedCall = goodReserve.interface.encodeFunctionData("setDistributionHelper", [distHelper.address]);
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [distHelper.address]
+    );
 
     await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
 
@@ -100,8 +104,11 @@ describe("GoodReserve - Distribution Helper", () => {
   };
 
   it("should allow avatar to set distribution helper target", async () => {
-    const { distHelper } = await waffle.loadFixture(fixture);
-    const encodedCall = goodReserve.interface.encodeFunctionData("setDistributionHelper", [distHelper.address]);
+    const { distHelper } = await loadFixture(fixture);
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [distHelper.address]
+    );
 
     await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
 
@@ -109,33 +116,41 @@ describe("GoodReserve - Distribution Helper", () => {
   });
 
   it("should not allow to call setDistributionHelper", async () => {
-    const { distHelper } = await waffle.loadFixture(fixture);
-    await expect(goodReserve.setDistributionHelper(distHelper.address)).to.be.revertedWith("avatar");
+    const { distHelper } = await loadFixture(fixture);
+    await expect(
+      goodReserve.setDistributionHelper(distHelper.address)
+    ).to.be.revertedWith(/avatar/);
   });
 
   it("should send UBI to distribution contract", async () => {
-    const { distHelper } = await waffle.loadFixture(deployed_fixture);
+    const { distHelper } = await loadFixture(deployed_fixture);
 
     await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
     await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
 
-    let tx = await (await goodReserve.connect(founder).mintUBI(0, 0, cDai)).wait();
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
 
     const ubiMintedEvent = tx.events.find(_ => _.event === "UBIMinted");
 
     const topic = distHelper.filters.Distribution().topics[0];
-    const distributionEvent = tx.events.find(_ => _.topics.includes(topic as string));
+    const distributionEvent = tx.events.find(_ =>
+      _.topics.includes(topic as string)
+    );
 
     //verify onDistribution didnt happen
     expect(distributionEvent).not.empty;
 
     //verify amount transfered
 
-    expect(ubiMintedEvent.args.gdUbiTransferred).to.equal(await goodDollar.balanceOf(distHelper.address));
+    expect(ubiMintedEvent.args.gdUbiTransferred).to.equal(
+      await goodDollar.balanceOf(distHelper.address)
+    );
   });
 
   it("should revert when DistributionHelper onDistribution reverts", async () => {
-    let { distHelper } = await waffle.loadFixture(deployed_revert_fixture); //using DistributionHelperTest which reverts
+    let { distHelper } = await loadFixture(deployed_revert_fixture); //using DistributionHelperTest which reverts
 
     await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
     await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
@@ -144,31 +159,38 @@ describe("GoodReserve - Distribution Helper", () => {
   });
 
   it("should trigger onDistribution of DistributionHelper", async () => {
-    let { distHelper } = await waffle.loadFixture(deployed_fixture); //using DistributionHelperTest which reverts
+    let { distHelper } = await loadFixture(deployed_fixture); //using DistributionHelperTest which reverts
 
     await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
     await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
 
-    let tx = await (await goodReserve.connect(founder).mintUBI(0, 0, cDai)).wait();
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
 
     const topic = distHelper.filters.Distribution().topics[0];
-    const distributionEvent = tx.events.find(_ => _.topics.includes(topic as string));
+    const distributionEvent = tx.events.find(_ =>
+      _.topics.includes(topic as string)
+    );
 
     expect(distributionEvent).not.empty;
   });
 
   it("should revert if distributionhelper is null", async () => {
-    let { distHelper } = await waffle.loadFixture(deployed_fixture); //using DistributionHelperTest which reverts
+    let { distHelper } = await loadFixture(deployed_fixture); //using DistributionHelperTest which reverts
 
     await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
     await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
 
-    const encodedCall = goodReserve.interface.encodeFunctionData("setDistributionHelper", [
-      ethers.constants.AddressZero
-    ]);
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [ethers.constants.AddressZero]
+    );
 
     await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
 
-    await expect(goodReserve.connect(founder).mintUBI(0, 0, cDai)).revertedWith("helper not set");
+    await expect(goodReserve.connect(founder).mintUBI(0, 0, cDai)).revertedWith(
+      /helper not set/
+    );
   });
 });

package/test/reserve/GoodReserveCDai.gdx.test.ts

@@ -312,6 +312,6 @@ describe("GDX Token", () => {
         "0xd515f7a623c1a18396a6aececcdcae32818b64faa0f536103b3a32e8c5ae7643"
       ]
     );
-    await expect(tx).to.be.revertedWith("already claimed gdx");
+    await expect(tx).to.be.revertedWith(/already claimed gdx/);
   });
 });

package/test/reserve/GoodReserveCDai.pause.test.ts

@@ -1,4 +1,4 @@
-import { ethers, waffle } from "hardhat";
+import { ethers } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GoodReserveCDai, DistributionHelper } from "../../types";
@@ -76,7 +76,7 @@ describe("GoodReserve - Distribution Helper", () => {
   };
 
   it("should allow avatar to unpause", async () => {
-    const { goodReserve } = await waffle.loadFixture(fixture);
+    const { goodReserve } = await loadFixture(fixture);
     const encodedCall = goodReserve.interface.encodeFunctionData("unpause");
 
     expect(await goodReserve.paused()).to.equal(true);
@@ -87,31 +87,31 @@ describe("GoodReserve - Distribution Helper", () => {
 
   it("should not be able to buy when paused", async () => {
     let amount = 1e8;
-    const { goodReserve } = await waffle.loadFixture(fixture);
+    const { goodReserve } = await loadFixture(fixture);
     await dai["mint(uint256)"](ethers.utils.parseEther("100"));
     await dai.approve(cDAI.address, ethers.utils.parseEther("100"));
     await cDAI["mint(uint256)"](ethers.utils.parseEther("100"));
     await cDAI.approve(goodReserve.address, ethers.utils.parseEther("10"));
     await expect(goodReserve.buy(amount, 0, founder.address)).revertedWith(
-      "paused"
+      /paused/
     );
   });
 
   it("should not be able to sell when paused", async () => {
-    const { goodReserve } = await waffle.loadFixture(fixture);
+    const { goodReserve } = await loadFixture(fixture);
     await expect(
       goodReserve.sell(1, 0, founder.address, founder.address)
-    ).revertedWith("paused");
+    ).revertedWith(/paused/);
   });
 
   it("should not be able to mint when paused", async () => {
-    const { goodReserve } = await waffle.loadFixture(fixture);
+    const { goodReserve } = await loadFixture(fixture);
     await setDAOAddress("FUND_MANAGER", founder.address);
 
     await expect(
       goodReserve
         .connect(founder)
         .mintRewardFromRR(cDAI.address, founder.address, 1000)
-    ).revertedWith("paused"); //10000 cdai wei is 1G$
+    ).revertedWith(/paused/); //10000 cdai wei is 1G$
   });
 });