@gooddollar/goodprotocol 2.0.21 → 2.0.22-beta.0

package/test/governance/GoodDollarStaking.gd.test.ts

@@ -1,4 +1,4 @@
-import { default as hre, ethers, upgrades, waffle } from "hardhat";
+import { default as hre, ethers, upgrades } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { Contract, Signer } from "ethers";
 import { expect } from "chai";
@@ -104,10 +104,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   }
 
   const fixture_staked1year = async (wallets, provider) => {
-    const { staking, goodDollarMintBurnWrapper } = await fixture_ready(
-      wallets,
-      provider
-    );
+    const { staking, goodDollarMintBurnWrapper } = await fixture_ready();
 
     await stake(staker1, STAKE_AMOUNT, staking);
     await advanceBlocks(BLOCKS_ONE_YEAR);
@@ -115,20 +112,13 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
     return { staking, goodDollarMintBurnWrapper };
   };
 
-  const fixture_ready = async (wallets, provider) => {
-    const f = await ethers.getContractFactory("GoodDollarStakingMock");
-
-    wallets = provider.getWallets();
-    const staking = (await waffle.deployContract(
-      wallets[0],
-      {
-        abi: JSON.parse(
-          f.interface.format(FormatTypes.json) as string
-        ) as any[],
-        bytecode: f.bytecode
-      },
-      [nameService.address, BN.from("1000000007735630000"), 518400 * 12, 30]
-    )) as GoodDollarStaking;
+  const fixture_ready = async () => {
+    const staking = (await ethers.deployContract("GoodDollarStakingMock", [
+      nameService.address,
+      BN.from("1000000007735630000"),
+      518400 * 12,
+      30
+    ])) as GoodDollarStaking;
 
     await staking.upgrade();
 
@@ -168,32 +158,17 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
     return { staking: staking.connect(staker1), goodDollarMintBurnWrapper };
   };
 
-  const fixture_upgradeTest = async (wallets, provider) => {
-    const f = await ethers.getContractFactory("GoodDollarStaking");
-    const gf = await ethers.getContractFactory("GovernanceStaking");
-
-    wallets = provider.getWallets();
-    const staking = (await waffle.deployContract(
-      wallets[0],
-      {
-        abi: JSON.parse(
-          f.interface.format(FormatTypes.json) as string
-        ) as any[],
-        bytecode: f.bytecode
-      },
-      [nameService.address, BN.from("1000000007735630000"), 518400 * 12, 30]
-    )) as GoodDollarStaking;
-
-    const govStaking = (await waffle.deployContract(
-      wallets[0],
-      {
-        abi: JSON.parse(
-          gf.interface.format(FormatTypes.json) as string
-        ) as any[],
-        bytecode: gf.bytecode
-      },
-      [nameService.address]
-    )) as GovernanceStaking;
+  const fixture_upgradeTest = async () => {
+    const staking = (await ethers.deployContract("GoodDollarStaking", [
+      nameService.address,
+      BN.from("1000000007735630000"),
+      518400 * 12,
+      30
+    ])) as GoodDollarStaking;
+
+    const govStaking = (await ethers.deployContract("GovernanceStaking", [
+      nameService.address
+    ])) as GovernanceStaking;
 
     await setDAOAddress("GDAO_STAKING", govStaking.address);
 
@@ -203,7 +178,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   };
 
   it("should update stakingrewardsfixedapy staker info and global stats when staking", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     const statsBefore = await staking.stats();
     const PRECISION = await staking.PRECISION();
 
@@ -229,7 +204,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should withdraw only rewards when calling withdrawRewards", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     // collect 350 earned rewards: 10,000 * 5%APY = 500 total rewards, minus 30% donation
     await stake(staker1, STAKE_AMOUNT, staking);
@@ -252,7 +227,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should withdraw from deposit and undo rewards if unable to mint rewards", async () => {
-    const { staking, goodDollarMintBurnWrapper } = await waffle.loadFixture(
+    const { staking, goodDollarMintBurnWrapper } = await loadFixture(
       fixture_ready
     );
     const PAUSE_ALL_ROLE = await goodDollarMintBurnWrapper.PAUSE_ALL_ROLE();
@@ -287,7 +262,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should withdraw rewards after mint rewards is enabled again", async () => {
-    const { staking, goodDollarMintBurnWrapper } = await waffle.loadFixture(
+    const { staking, goodDollarMintBurnWrapper } = await loadFixture(
       fixture_ready
     );
     const PAUSE_ALL_ROLE = await goodDollarMintBurnWrapper.PAUSE_ALL_ROLE();
@@ -326,18 +301,16 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
         518400 * 12,
         61
       )
-    ).revertedWith("max two");
+    ).revertedWith(/max two/);
   });
 
   it("should not perform upgrade when not deadline", async () => {
-    const { staking } = await waffle.loadFixture(fixture_upgradeTest);
-    await expect(staking.upgrade()).to.revertedWith("deadline");
+    const { staking } = await loadFixture(fixture_upgradeTest);
+    await expect(staking.upgrade()).to.revertedWith(/deadline/);
   });
 
   it("should perform upgrade after deadline", async () => {
-    const { staking, govStaking } = await waffle.loadFixture(
-      fixture_upgradeTest
-    );
+    const { staking, govStaking } = await loadFixture(fixture_upgradeTest);
 
     const gdaoStakingBefore = await nameService.getAddress("GDAO_STAKING");
 
@@ -362,7 +335,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should set APY and change getRewardsPerBlock only by avatar", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const [, gdRewardsPerBlockBeforeSet] = await staking.getRewardsPerBlock();
     expect(gdRewardsPerBlockBeforeSet.add(1)).to.equal(INTEREST_RATE_5APY_X64);
@@ -383,7 +356,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should be pausable by avatar", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await runAsAvatarOnly(staking, "pause(bool,uint128)", true, "0");
     expect(await staking.paused()).to.equal(true);
@@ -402,14 +375,14 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should not be able to stake when paused", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await runAsAvatarOnly(staking, "pause(bool,uint128)", true, "0");
-    await expect(stake(staker2, "1000", staking)).to.revertedWith("pause");
+    await expect(stake(staker2, "1000", staking)).to.revertedWith(/pause/);
   });
 
   it("should have max yearly apy of 20%", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await runAsAvatarOnly(staking, "setGdApy(uint128)", "1000000029000000000");
 
@@ -424,7 +397,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should handle stakingrewardsfixed apy correctly when transfering staking tokens to new staker", async () => {
-    const { staking } = await waffle.loadFixture(fixture_staked1year);
+    const { staking } = await loadFixture(fixture_staked1year);
 
     const RECEIVER_STAKE = 10000;
     const receiver = staker2;
@@ -480,7 +453,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should be able to stake using onTokenTransfer", async () => {
-    const { staking, goodDollarMintBurnWrapper } = await waffle.loadFixture(
+    const { staking, goodDollarMintBurnWrapper } = await loadFixture(
       fixture_ready
     );
 
@@ -499,7 +472,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should asure getStaked returns correct value", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     // correct after stake
     await stake(staker1, STAKE_AMOUNT, staking);
@@ -522,7 +495,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("it should return getUserPendingReward G$ value equal to earned() rewards after donation", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     await stake(staker1, STAKE_AMOUNT, staking);
     await advanceBlocks(BLOCKS_ONE_YEAR);
 
@@ -537,7 +510,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("should return G$ totalRewardsPerShare equal sharePrice()", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     await stake(staker1, STAKE_AMOUNT, staking);
     await advanceBlocks(BLOCKS_ONE_YEAR);
     const stats = await staking.stats();
@@ -559,18 +532,18 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
   });
 
   it("it should not upgrade if no balance or target is not approved by dao", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     await expect(
       staking.connect(staker1).upgradeTo(signers[10].address)
-    ).revertedWith("no balance");
+    ).revertedWith(/no balance/);
     await stake(staker1, STAKE_AMOUNT, staking);
     await expect(
       staking.connect(staker1).upgradeTo(signers[10].address)
-    ).revertedWith("not DAO approved");
+    ).revertedWith(/not DAO approved/);
   });
 
   it("it should not upgrade if cant mint rewards", async () => {
-    const { staking, goodDollarMintBurnWrapper } = await waffle.loadFixture(
+    const { staking, goodDollarMintBurnWrapper } = await loadFixture(
       fixture_ready
     );
     await stake(staker1, STAKE_AMOUNT, staking);
@@ -600,11 +573,11 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
 
     await expect(
       staking.connect(staker1).upgradeTo(signers[10].address)
-    ).revertedWith("unable to mint rewards");
+    ).revertedWith(/unable to mint rewards/);
   });
 
   it("it should upgrade and transfer funds to new staking contract", async () => {
-    const { staking, goodDollarMintBurnWrapper } = await waffle.loadFixture(
+    const { staking, goodDollarMintBurnWrapper } = await loadFixture(
       fixture_ready
     );
     await stake(staker1, STAKE_AMOUNT, staking);

package/test/governance/GoodDollarStaking.good.test.ts

@@ -1,4 +1,4 @@
-import { default as hre, ethers, waffle } from "hardhat";
+import { default as hre, ethers } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract, Signer } from "ethers";
 import { expect } from "chai";
@@ -70,40 +70,26 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
     // await goodReserve.setAddresses();
   });
 
-  const fixture = async (wallets, provider) => {
-    const f = await ethers.getContractFactory("GoodDollarStakingMock");
-
-    wallets = provider.getWallets();
-    const staking = (await waffle.deployContract(
-      wallets[0],
-      {
-        abi: JSON.parse(
-          f.interface.format(FormatTypes.json) as string
-        ) as any[],
-        bytecode: f.bytecode
-      },
-      [nameService.address, BN.from("1000000007735630000"), 518400 * 12, 30]
-    )) as GoodDollarStaking;
+  const fixture = async () => {
+    const staking = (await ethers.deployContract("GoodDollarStakingMock", [
+      nameService.address,
+      BN.from("1000000007735630000"),
+      518400 * 12,
+      30
+    ])) as GoodDollarStaking;
 
     await staking.upgrade();
 
     return { staking };
   };
 
-  const fixture_ready = async (wallets, provider) => {
-    const f = await ethers.getContractFactory("GoodDollarStakingMock");
-
-    wallets = provider.getWallets();
-    const staking = (await waffle.deployContract(
-      wallets[0],
-      {
-        abi: JSON.parse(
-          f.interface.format(FormatTypes.json) as string
-        ) as any[],
-        bytecode: f.bytecode
-      },
-      [nameService.address, BN.from("1000000007735630000"), 518400 * 12, 30]
-    )) as GoodDollarStaking;
+  const fixture_ready = async () => {
+    const staking = (await ethers.deployContract("GoodDollarStakingMock", [
+      nameService.address,
+      BN.from("1000000007735630000"),
+      518400 * 12,
+      30
+    ])) as GoodDollarStaking;
 
     await staking.upgrade();
 
@@ -112,20 +98,13 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
     return { staking };
   };
 
-  const fixture_upgradeTest = async (wallets, provider) => {
-    const f = await ethers.getContractFactory("GoodDollarStaking");
-
-    wallets = provider.getWallets();
-    const staking = (await waffle.deployContract(
-      wallets[0],
-      {
-        abi: JSON.parse(
-          f.interface.format(FormatTypes.json) as string
-        ) as any[],
-        bytecode: f.bytecode
-      },
-      [nameService.address, BN.from("1000000007735630000"), 518400 * 12, 30]
-    )) as GoodDollarStaking;
+  const fixture_upgradeTest = async () => {
+    const staking = (await ethers.deployContract("GoodDollarStaking", [
+      nameService.address,
+      BN.from("1000000007735630000"),
+      518400 * 12,
+      30
+    ])) as GoodDollarStaking;
 
     //TODO: register as scheme here
 
@@ -133,7 +112,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   };
 
   it("Should not revert withdraw but also not mint GOOD reward when staking contract is not minter", async () => {
-    const { staking } = await waffle.loadFixture(fixture);
+    const { staking } = await loadFixture(fixture);
     await goodDollar.mint(founder.address, "100");
     await goodDollar.approve(staking.address, "100");
     await staking.stake("100");
@@ -145,7 +124,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("Should be able to mint rewards after set GDAO staking contract", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await goodDollar.mint(founder.address, "100");
     await goodDollar.approve(staking.address, "100");
@@ -162,7 +141,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("Avatar should be able to change rewards per block", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const ictrl = await ethers.getContractAt(
       "Controller",
@@ -198,7 +177,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("Should be able to withdraw rewards without withdraw stake", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     const rewardsPerBlock = (await staking.getRewardsPerBlock())[0];
     await goodDollar.mint(founder.address, "100");
     await goodDollar.approve(staking.address, "100");
@@ -221,7 +200,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("Should be able to withdraw transferred stakes", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await goodDollar.mint(staker.address, "100");
     await goodDollar.connect(staker).approve(staking.address, "100");
@@ -240,7 +219,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("should not be able to withdraw after they send their stake to somebody else", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await goodDollar.mint(staker.address, "100");
     await goodDollar.connect(staker).approve(staking.address, "100");
@@ -251,12 +230,12 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
       .transfer(founder.address, await staking.balanceOf(staker.address));
 
     await expect(staking.connect(staker).withdrawStake(1)).revertedWith(
-      "no balance"
+      /no balance/
     );
   });
 
   it("it should distribute reward with correct precision", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const ictrl = await ethers.getContractAt(
       "Controller",
@@ -290,7 +269,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should not generate rewards when rewards per block set to 0", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const ictrl = await ethers.getContractAt(
       "Controller",
@@ -321,7 +300,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should return productivity values correctly", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     await goodDollar.mint(founder.address, "100");
     await goodDollar.approve(staking.address, "100");
     await staking.stake("100");
@@ -336,7 +315,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should return earned rewards with pending ones properly for a short period", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     const rewardsPerBlock = (await staking.getRewardsPerBlock())[0];
     await goodDollar.mint(founder.address, "100");
     await goodDollar.approve(staking.address, "100");
@@ -354,7 +333,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("Accumulated per share has enough precision when reward << totalproductivity", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const rewardsPerBlock = (await staking.getRewardsPerBlock())[0];
     await goodDollar.mint(founder.address, "100000000000000"); // 1 trillion gd stake
@@ -376,7 +355,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("user receive fractional gdao properly when his stake << totalProductivity", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const rewardsPerBlock = (await staking.getRewardsPerBlock())[0];
     await goodDollar.mint(founder.address, "800"); // 8gd
@@ -426,7 +405,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should be able to tranfer tokens when user approve", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await goodDollar.mint(founder.address, "100");
     await goodDollar.approve(staking.address, "100");
@@ -453,7 +432,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should return staker data", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await goodDollar.mint(staker2.address, "200");
     await goodDollar.connect(staker2).approve(staking.address, "200");
@@ -498,7 +477,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should return pendingRewards equal zero after withdraw", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await goodDollar.mint(staker.address, "200");
     await goodDollar.connect(staker).approve(staking.address, "200");
@@ -530,7 +509,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should calculate accumulated rewards per share correctly", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await goodDollar.mint(founder.address, "200");
     await goodDollar.mint(staker.address, "200");
@@ -602,33 +581,33 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("Staking tokens should be 18 decimals", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const decimals = await staking.decimals();
     expect(decimals.toString()).to.be.equal("18");
   });
 
   it("Stake amount should be positive", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
-    await expect(staking.stake("0")).revertedWith("Cannot stake 0");
+    await expect(staking.stake("0")).revertedWith(/Cannot stake 0/);
   });
 
   it("It should approve stake amount in order to stake", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await expect(staking.stake(ethers.utils.parseEther("10000000"))).to
       .reverted;
   });
 
   it("Withdraw 0 should succeed", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await expect(staking.withdrawStake("0")).to.not.reverted;
   });
 
   it("Withdraw uint max should withdraw everything", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     await goodDollar.mint(staker2.address, "200");
     await goodDollar.connect(staker2).approve(staking.address, "200");
@@ -645,7 +624,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("Should use overriden _transfer that handles productivity when using transferFrom which is defined in super erc20 contract", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     await expect(
       staking.transferFrom(
         founder.address,
@@ -656,7 +635,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should get rewards for previous stakes when stake new amount of tokens", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const rewardsPerBlock = (await staking.getRewardsPerBlock())[0];
     await goodDollar.mint(founder.address, "200");
@@ -681,7 +660,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should distribute rewards properly when there are multiple stakers", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const rewardsPerBlock = (await staking.getRewardsPerBlock())[0];
     const stakingAmount = BN.from("100");
@@ -832,7 +811,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should get staking reward even when stake amount is low", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const rewardsPerBlock = (await staking.getRewardsPerBlock())[0];
     const stakingAmount = BN.from("10000");
@@ -891,7 +870,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should mint rewards properly when withdrawRewards", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
     await goodDollar.mint(founder.address, "200");
     const rewardsPerBlock = (await staking.getRewardsPerBlock())[0];
     await goodDollar.approve(staking.address, "200");
@@ -912,7 +891,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should not overmint rewards when staker withdraw their rewards", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const overmintTesterFactory = await ethers.getContractFactory(
       "OverMintTester"
@@ -962,7 +941,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
   });
 
   it("it should accrue previous rewards based on previous monthly rate on monthly rewards rate change to 0", async () => {
-    const { staking } = await waffle.loadFixture(fixture_ready);
+    const { staking } = await loadFixture(fixture_ready);
 
     const ictrl = await ethers.getContractAt(
       "Controller",

package/test/governance/GovernanceStaking.test.ts

@@ -588,7 +588,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
 
   it("Withdraw 0 should withdraw everything", async () => {
     await expect(governanceStaking.withdrawStake("0")).to.revertedWith(
-      "positive amount"
+      /positive amount/
     );
   });
 

package/test/governance/Reputation.test.ts

@@ -48,8 +48,8 @@ describe("Reputation", () => {
     await reputation.mint(signers[1].address, 1000);
 
     // only the owner can call mint
-    await expect(reputation.connect(signers[2]).mint(signers[2], 1000)).to
-      .reverted;
+    await expect(reputation.connect(signers[2]).mint(signers[2].address, 1000))
+      .to.reverted;
 
     let account0Rep = await reputation.balanceOfLocal(signers[0].address);
     let account1Rep = await reputation.balanceOfLocal(signers[1].address);

package/test/helpers.ts

@@ -357,7 +357,7 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
     const functionName = functionAbi.substring(0, funcNameEnd);
 
     await expect(contract[functionAbi](...parameters)).to.revertedWith(
-      "avatar"
+      /avatar/
     );
     const encoded = contract.interface.encodeFunctionData(functionName, [
       ...parameters