@gooddollar/goodprotocol 2.0.21 → 2.0.22-beta.0

package/scripts/blockchainTestSetup.sh

@@ -7,7 +7,7 @@ export MNEMONIC='test test test test test test test test test test test junk'
 export ADMIN_MNEMONIC='test test test test test test test test test test test junk'
 yarn set version 3.6.0
 echo "nodeLinker: node-modules" >> .yarnrc.yml
-yarn --immutable
+yarn
 npx patch-package
 yarn runNode &
 sleep 30

package/test/faucet/Faucet.test.ts

@@ -8,7 +8,10 @@ import { createDAO } from "../helpers";
 const BN = ethers.BigNumber;
 ["FuseFaucetV2", "Faucet"].forEach(factory => {
   describe(factory, () => {
-    let faucet: FuseFaucetV2 | Faucet, founder: SignerWithAddress, fuseFaucet: FuseFaucetV2, faucets;
+    let faucet: FuseFaucetV2 | Faucet,
+      founder: SignerWithAddress,
+      fuseFaucet: FuseFaucetV2,
+      faucets;
     let user1 = ethers.Wallet.createRandom().connect(ethers.provider);
     let user2 = ethers.Wallet.createRandom().connect(ethers.provider);
     let signers;
@@ -21,7 +24,14 @@ const BN = ethers.BigNumber;
 
       const FuseFaucetF = await ethers.getContractFactory(factory);
 
-      let { daoCreator, controller, avatar: av, gd: gooddollar, identity, nameService } = await loadFixture(createDAO);
+      let {
+        daoCreator,
+        controller,
+        avatar: av,
+        gd: gooddollar,
+        identity,
+        nameService
+      } = await loadFixture(createDAO);
 
       Controller = controller;
       avatar = av;
@@ -50,8 +60,16 @@ const BN = ethers.BigNumber;
         }
       )) as FuseFaucetV2;
 
-      gd = (await ethers.getContractAt("IGoodDollar", gooddollar, founder)) as IGoodDollar;
-      id = (await ethers.getContractAt("IIdentity", identity, founder)) as IIdentity;
+      gd = (await ethers.getContractAt(
+        "IGoodDollar",
+        gooddollar,
+        founder
+      )) as IGoodDollar;
+      id = (await ethers.getContractAt(
+        "IIdentity",
+        identity,
+        founder
+      )) as IIdentity;
 
       await founder.sendTransaction({
         value: ethers.utils.parseEther("1"),
@@ -68,12 +86,16 @@ const BN = ethers.BigNumber;
 
     it("should not unauthorized to top new user", async () => {
       expect(await faucet.canTop(user1.address)).to.true;
-      await expect(faucet.topWallet(user1.address)).revertedWith("not authorized");
+      await expect(faucet.topWallet(user1.address)).revertedWith(
+        /not authorized/
+      );
     });
 
     it("should let new user top once", async () => {
       expect(await faucet.canTop(user1.address)).to.true;
-      const tx = await (await faucet.connect(signers[0]).topWallet(user1.address)).wait();
+      const tx = await (
+        await faucet.connect(signers[0]).topWallet(user1.address)
+      ).wait();
       const balance = await ethers.provider.getBalance(user1.address);
       expect(balance).to.equal(await faucet.getToppingAmount());
     });
@@ -84,18 +106,22 @@ const BN = ethers.BigNumber;
         value: ethers.utils.parseUnits("400000", "gwei")
       });
       expect(await faucet.canTop(user1.address)).to.false;
-      await expect(faucet.connect(signers[0]).topWallet(user1.address)).to.revertedWith(
-        "User not whitelisted or not first time"
-      );
+      await expect(
+        faucet.connect(signers[0]).topWallet(user1.address)
+      ).to.revertedWith(/User not whitelisted or not first time/);
     });
 
     it("should not refund gas when reverted", async () => {
       const balance = await ethers.provider.getBalance(founder.address);
       const faucetBalance = await ethers.provider.getBalance(faucet.address);
       expect(await faucet.canTop(user1.address)).to.false;
-      await expect(faucet.topWallet(user1.address)).to.revertedWith("User not whitelisted or not first time");
+      await expect(faucet.topWallet(user1.address)).to.revertedWith(
+        /User not whitelisted or not first time/
+      );
       const balanceAfter = await ethers.provider.getBalance(founder.address);
-      const faucetBalanceAfter = await ethers.provider.getBalance(faucet.address);
+      const faucetBalanceAfter = await ethers.provider.getBalance(
+        faucet.address
+      );
       expect(faucetBalanceAfter).to.eq(faucetBalance);
       expect(balanceAfter).to.lt(balance);
     });
@@ -103,7 +129,9 @@ const BN = ethers.BigNumber;
     it("should let user top again once identified", async () => {
       await user1.sendTransaction({
         to: ethers.constants.AddressZero,
-        value: (await ethers.provider.getBalance(user1.address)).sub(ethers.utils.parseUnits("100000", "gwei"))
+        value: (
+          await ethers.provider.getBalance(user1.address)
+        ).sub(ethers.utils.parseUnits("100000", "gwei"))
       });
       await id.addWhitelistedWithDID(user1.address, "did:1");
       expect(await faucet.canTop(user1.address)).to.true;
@@ -116,7 +144,9 @@ const BN = ethers.BigNumber;
     it("should not let identified user top over daily limit", async () => {
       await user1.sendTransaction({
         to: ethers.constants.AddressZero,
-        value: (await ethers.provider.getBalance(user1.address)).sub(ethers.utils.parseUnits("100000", "gwei"))
+        value: (
+          await ethers.provider.getBalance(user1.address)
+        ).sub(ethers.utils.parseUnits("100000", "gwei"))
       });
       const tx = await (await faucet.topWallet(user1.address)).wait();
       await user1.sendTransaction({
@@ -124,7 +154,9 @@ const BN = ethers.BigNumber;
         value: ethers.utils.parseUnits("400000", "gwei")
       });
       expect(await faucet.canTop(user1.address)).to.false;
-      await expect(faucet.topWallet(user1.address)).to.revertedWith("max daily toppings");
+      await expect(faucet.topWallet(user1.address)).to.revertedWith(
+        /max daily toppings/
+      );
     });
 
     // it("should not top if wallet not half empty", async () => {
@@ -152,7 +184,7 @@ const BN = ethers.BigNumber;
       // await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
 
       await expect(faucet.topWallet(user1.address)).to.revertedWith(
-        "User wallet has been topped too many times this week"
+        /User wallet has been topped too many times this week/
       );
       expect(await faucet.canTop(user1.address)).to.false;
 
@@ -170,11 +202,19 @@ const BN = ethers.BigNumber;
       console.log(toppingAmount.toString(), "topping amount");
       const minTopping = await faucet.minTopping();
       const balance = await ethers.provider.getBalance(founder.address);
-      await founder.sendTransaction({ to: user2.address, value: toppingAmount.mul(100 - minTopping + 1).div(100) });
+      await founder.sendTransaction({
+        to: user2.address,
+        value: toppingAmount.mul(100 - minTopping + 1).div(100)
+      });
 
       expect(await faucet.canTop(user2.address)).to.be.false;
-      await expect(faucet.topWallet(user2.address)).to.revertedWith("low toTop");
-      await user2.sendTransaction({ to: founder.address, value: toppingAmount.mul(2).div(100) });
+      await expect(faucet.topWallet(user2.address)).to.revertedWith(
+        /low toTop/
+      );
+      await user2.sendTransaction({
+        to: founder.address,
+        value: toppingAmount.mul(2).div(100)
+      });
       expect(await faucet.canTop(user2.address)).to.be.true;
       await expect(faucet.topWallet(user2.address)).not.reverted;
     });
@@ -183,7 +223,11 @@ const BN = ethers.BigNumber;
       const tempUser = ethers.Wallet.createRandom().connect(ethers.provider);
 
       const balance = await ethers.provider.getBalance(founder.address);
-      const tx = await (await faucet.connect(signers[0]).topWallet(tempUser.address, { gasPrice: 1e9 })).wait();
+      const tx = await (
+        await faucet
+          .connect(signers[0])
+          .topWallet(tempUser.address, { gasPrice: 1e9 })
+      ).wait();
       // const gasCosts = tx.gasUsed.mul(1e9);
       // const afterRefund = gasCosts.sub(await faucet["gasRefund()"]());
       const balanceAfter = await ethers.provider.getBalance(founder.address);

package/test/faucet/FuseFaucet.test.ts

@@ -20,7 +20,14 @@ describe("FuseFaucet", () => {
 
     const FuseFaucetF = await ethers.getContractFactory("FuseFaucet");
 
-    let { daoCreator, controller, avatar: av, gd: gooddollar, identity, nameService } = await loadFixture(createDAO);
+    let {
+      daoCreator,
+      controller,
+      avatar: av,
+      gd: gooddollar,
+      identity,
+      nameService
+    } = await loadFixture(createDAO);
 
     Controller = controller;
     avatar = av;
@@ -38,8 +45,16 @@ describe("FuseFaucet", () => {
       kind: "transparent"
     })) as FuseFaucet;
 
-    gd = (await ethers.getContractAt("IGoodDollar", gooddollar, founder)) as IGoodDollar;
-    id = (await ethers.getContractAt("IIdentity", identity, founder)) as IIdentity;
+    gd = (await ethers.getContractAt(
+      "IGoodDollar",
+      gooddollar,
+      founder
+    )) as IGoodDollar;
+    id = (await ethers.getContractAt(
+      "IIdentity",
+      identity,
+      founder
+    )) as IIdentity;
 
     await founder.sendTransaction({
       value: ethers.utils.parseEther("1"),
@@ -52,13 +67,19 @@ describe("FuseFaucet", () => {
     const faucet = await upgrades.deployProxy(FaucetV1, [id.address], {
       kind: "transparent"
     });
-    const res = await upgrades.upgradeProxy(faucet.address, await ethers.getContractFactory("FuseFaucetV2"), {
-      kind: "transparent",
-      unsafeAllowRenames: true,
-      call: { fn: "upgrade", args: [signers[1].address, founder.address, ns] }
-    });
+    const res = await upgrades.upgradeProxy(
+      faucet.address,
+      await ethers.getContractFactory("FuseFaucetV2"),
+      {
+        kind: "transparent",
+        unsafeAllowRenames: true,
+        call: { fn: "upgrade", args: [signers[1].address, founder.address, ns] }
+      }
+    );
     expect(res).not.empty;
-    await expect(res.upgrade(signers[0].address, signers[0].address, ns)).revertedWith("wrong upgrade version");
+    await expect(
+      res.upgrade(signers[0].address, signers[0].address, ns)
+    ).revertedWith(/wrong upgrade version/);
     expect(await res.owner()).equal(founder.address);
     expect(await res.relayer()).equal(signers[1].address);
   });
@@ -81,14 +102,18 @@ describe("FuseFaucet", () => {
       value: ethers.utils.parseUnits("400000", "gwei")
     });
     expect(await faucet.canTop(user1.address)).to.false;
-    await expect(faucet.topWallet(user1.address)).to.revertedWith("User not whitelisted or not first time");
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      /User not whitelisted or not first time/
+    );
   });
 
   it("should not refund gas when reverted", async () => {
     const balance = await ethers.provider.getBalance(founder.address);
     const faucetBalance = await ethers.provider.getBalance(faucet.address);
     expect(await faucet.canTop(user1.address)).to.false;
-    await expect(faucet.topWallet(user1.address)).to.revertedWith("User not whitelisted or not first time");
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      /User not whitelisted or not first time/
+    );
     const balanceAfter = await ethers.provider.getBalance(founder.address);
     const faucetBalanceAfter = await ethers.provider.getBalance(faucet.address);
     expect(faucetBalanceAfter).to.eq(faucetBalance);
@@ -115,7 +140,9 @@ describe("FuseFaucet", () => {
       value: ethers.utils.parseUnits("400000", "gwei")
     });
     expect(await faucet.canTop(user1.address)).to.false;
-    await expect(faucet.topWallet(user1.address)).to.revertedWith("max daily toppings");
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      /max daily toppings/
+    );
   });
 
   // it("should not top if wallet not half empty", async () => {
@@ -138,7 +165,7 @@ describe("FuseFaucet", () => {
 
     expect(await faucet.canTop(user1.address)).to.false;
     await expect(faucet.topWallet(user1.address)).to.revertedWith(
-      "User wallet has been topped too many times this week"
+      /User wallet has been topped too many times this week/
     );
 
     //should be able to top again after some days passed
@@ -150,7 +177,9 @@ describe("FuseFaucet", () => {
 
   it("should reimburse gas costs", async () => {
     const balance = await ethers.provider.getBalance(founder.address);
-    const tx = await (await faucet.topWallet(user2.address, { gasPrice: 1e9 })).wait();
+    const tx = await (
+      await faucet.topWallet(user2.address, { gasPrice: 1e9 })
+    ).wait();
     // const gasCosts = tx.gasUsed.mul(1e9);
     // const afterRefund = gasCosts.sub(await faucet["gasRefund()"]());
     const balanceAfter = await ethers.provider.getBalance(founder.address);

package/test/governance/ClaimersDistribution.test.ts

@@ -95,7 +95,7 @@ describe("ClaimersDistribution", () => {
   it("should not be able to set monthly distribution", async () => {
     await expect(
       cd["setMonthlyReputationDistribution(uint256)"](10)
-    ).to.revertedWith("only avatar");
+    ).to.revertedWith(/only avatar/);
   });
 
   it("should be able to set monthly distribution by avatar", async () => {
@@ -109,7 +109,7 @@ describe("ClaimersDistribution", () => {
 
   it("should not update claim if didnt claim today", async () => {
     await expect(cd.updateClaim(claimer1.address)).to.revertedWith(
-      "ClaimersDistribution: didn't claim today"
+      /ClaimersDistribution: didn't claim today/
     );
   });
 
@@ -127,7 +127,7 @@ describe("ClaimersDistribution", () => {
 
   it("should not update claim if already updated", async () => {
     await expect(cd.updateClaim(claimer1.address)).to.revertedWith(
-      "ClaimersDistribution: already updated"
+      /ClaimersDistribution: already updated/
     );
   });
 

package/test/governance/CompoundVotingMachine.castvote.test.ts

@@ -63,8 +63,7 @@ describe("CompoundVotingMachine#CastVote", () => {
 
   describe("We must revert if:", () => {
     it("There does not exist a proposal with matching proposal id where the current block number is between the proposal's start block (exclusive) and end block (inclusive)", async () => {
-      await expect(gov.castVote(proposalId, true)).to.revertedWith(
-        "CompoundVotingMachine::_castVote: voting is closed"
+      await expect(gov.castVote(proposalId, true)).to.revertedWith(/CompoundVotingMachine::_castVote: voting is closed/
       );
     });
 
@@ -72,8 +71,7 @@ describe("CompoundVotingMachine#CastVote", () => {
       await gov.connect(signers[0]).castVote(proposalId, true);
       await expect(
         gov.connect(signers[0]).castVote(proposalId, true)
-      ).to.revertedWith(
-        "CompoundVotingMachine::_castVote: voter already voted"
+      ).to.revertedWith(/CompoundVotingMachine::_castVote: voter already voted/
       );
     });
   });
@@ -166,8 +164,7 @@ describe("CompoundVotingMachine#CastVote", () => {
               ethers.utils.hexZeroPad("0xbac", 32),
               ethers.utils.hexZeroPad("0xbada", 32)
             )
-          ).to.revertedWith(
-            "CompoundVotingMachine::castVoteBySig: invalid signature"
+          ).to.revertedWith(/CompoundVotingMachine::castVoteBySig: invalid signature/
           );
         });
 

package/test/governance/CompoundVotingMachine.crossblockchain.ts

@@ -62,7 +62,7 @@ describe("CompoundVotingMachine#cross blockchain", () => {
 
   it("reverts emit succeeded if not passed", async () => {
     await expect(gov.emitSucceeded(await gov.proposalCount())).to.revertedWith(
-      "not Succeeded"
+      /not Succeeded/
     );
   });
 
@@ -72,7 +72,7 @@ describe("CompoundVotingMachine#cross blockchain", () => {
     await increaseTime(queuePeriod);
 
     await expect(gov.execute(await gov.proposalCount())).to.revertedWith(
-      "wrong blockchain"
+      /wrong blockchain/
     );
   });
 

package/test/governance/CompoundVotingMachine.daoscheme.ts

@@ -163,7 +163,7 @@ describe("CompoundVotingMachine#DAOScheme", () => {
   it("Should not be able to change params if not avatar", async () => {
     await expect(
       gov.setVotingParameters([0, 0, 0, 0, 0, 0, 0, 0, 0])
-    ).to.revertedWith("only avatar");
+    ).to.revertedWith(/only avatar/);
   });
 
   it("Should be able to propose parameters changes", async () => {

package/test/governance/CompoundVotingMachine.guardian.test.ts

@@ -1,4 +1,4 @@
-import hre, { ethers, upgrades, waffle } from "hardhat";
+import hre, { ethers, upgrades } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GReputation, CompoundVotingMachine } from "../../types";
@@ -100,7 +100,7 @@ describe("CompoundVotingMachine#Guardian", () => {
   it("Should not be able to change guardian if not guardian or avatar", async () => {
     await expect(
       gov.connect(acct).setGuardian(acct.address)
-    ).to.be.revertedWith("CompoundVotingMachine: not avatar or guardian");
+    ).to.be.revertedWith(/CompoundVotingMachine: not avatar or guardian/);
   });
 
   it("Should not be able to change guardian before foundation release time by avatar", async () => {
@@ -113,7 +113,7 @@ describe("CompoundVotingMachine#Guardian", () => {
 
   it("Should not be able to renounce guardian if not guardian", async () => {
     await expect(gov.connect(acct).renounceGuardian()).to.be.revertedWith(
-      "CompoundVotingMachine: not guardian"
+      /CompoundVotingMachine: not guardian/
     );
   });
 
@@ -196,7 +196,7 @@ describe("CompoundVotingMachine#Guardian", () => {
     await advanceBlocks(1);
 
     await expect(gov.cancel(proposalId)).to.be.revertedWith(
-      "CompoundVotingMachine::cancel: proposer above threshold"
+      /CompoundVotingMachine::cancel: proposer above threshold/
     ); //should not be cancelable by anyone else buy guardian
 
     await gov.connect(signers[1]).cancel(proposalId);

package/test/governance/CompoundVotingMachine.propose.test.ts

@@ -72,7 +72,7 @@ describe("CompoundVotingMachine#propose", () => {
         "do nothing"
       )
     ).to.revertedWith(
-      "CompoundVotingMachine::propose: one live proposal per proposer, found an already pending proposal"
+      /CompoundVotingMachine::propose: one live proposal per proposer, found an already pending proposal/
     );
   });
 
@@ -144,7 +144,7 @@ describe("CompoundVotingMachine#propose", () => {
             "do nothing"
           )
         ).to.revertedWith(
-          "CompoundVotingMachine::propose: one live proposal per proposer, found an already active proposal"
+          /CompoundVotingMachine::propose: one live proposal per proposer, found an already active proposal/
         );
       });
     });
@@ -162,7 +162,7 @@ describe("CompoundVotingMachine#propose", () => {
               "do nothing"
             )
         ).to.revertedWith(
-          "CompoundVotingMachine::propose: proposer votes below proposal threshold"
+          /CompoundVotingMachine::propose: proposer votes below proposal threshold/
         );
       });
 
@@ -176,7 +176,7 @@ describe("CompoundVotingMachine#propose", () => {
             "do nothing"
           )
         ).to.revertedWith(
-          "CompoundVotingMachine::propose: proposal function information arity mismatch"
+          /CompoundVotingMachine::propose: proposal function information arity mismatch/
         );
 
         await expect(
@@ -188,7 +188,7 @@ describe("CompoundVotingMachine#propose", () => {
             "do nothing"
           )
         ).to.revertedWith(
-          "CompoundVotingMachine::propose: proposal function information arity mismatch"
+          /CompoundVotingMachine::propose: proposal function information arity mismatch/
         );
 
         await expect(
@@ -200,7 +200,7 @@ describe("CompoundVotingMachine#propose", () => {
             "do nothing"
           )
         ).to.revertedWith(
-          "CompoundVotingMachine::propose: proposal function information arity mismatch"
+          /CompoundVotingMachine::propose: proposal function information arity mismatch/
         );
 
         await expect(
@@ -212,7 +212,7 @@ describe("CompoundVotingMachine#propose", () => {
             "do nothing"
           )
         ).to.revertedWith(
-          "CompoundVotingMachine::propose: proposal function information arity mismatch"
+          /CompoundVotingMachine::propose: proposal function information arity mismatch/
         );
       });
 
@@ -226,7 +226,7 @@ describe("CompoundVotingMachine#propose", () => {
             "do nothing"
           )
         ).to.revertedWith(
-          "CompoundVotingMachine::propose: must provide actions"
+          /CompoundVotingMachine::propose: must provide actions/
         );
       });
     });

package/test/governance/CompoundVotingMachine.state.test.ts

@@ -111,7 +111,7 @@ describe("CompoundVotingMachine#States", () => {
 
   it("Invalid for proposal not found", async () => {
     await expect(gov.state(5)).to.revertedWith(
-      "CompoundVotingMachine::state: invalid proposal id"
+      /CompoundVotingMachine::state: invalid proposal id/
     );
   });
 
@@ -190,7 +190,7 @@ describe("CompoundVotingMachine#States", () => {
       await expect(
         gov.connect(acct).castVote(proposalId, false)
       ).to.be.revertedWith(
-        "CompoundVotingMachine::_castVote: voting is closed"
+        /CompoundVotingMachine::_castVote: voting is closed/
       );
     });
 
@@ -198,7 +198,7 @@ describe("CompoundVotingMachine#States", () => {
       await increaseTime(10);
       expect(states[await gov.state(proposalId)]).to.equal("Expired");
       await expect(gov.execute(proposalId)).to.be.revertedWith(
-        "CompoundVotingMachine::execute: proposal can only be executed if it is succeeded"
+        /CompoundVotingMachine::execute: proposal can only be executed if it is succeeded/
       );
     });
   });
@@ -270,7 +270,7 @@ describe("CompoundVotingMachine#States", () => {
     let actor = signers[1];
     let proposalId = await gov.latestProposalIds(actor.address);
     await expect(gov.cancel(proposalId)).to.be.revertedWith(
-      "cannot cancel executed proposal"
+      /cannot cancel executed proposal/
     );
   });
 

package/test/governance/GReputation.test.ts

@@ -136,10 +136,10 @@ describe("GReputation", () => {
 
   it("should not be able to mint or burn if not minter", async () => {
     await expect(grep.connect(signers[4]).mint(founder, 2)).to.revertedWith(
-      "GReputation: need minter role or be GDAO contract"
+      /GReputation: need minter role or be GDAO contract/
     );
     await expect(grep.connect(signers[4]).burn(founder, 2)).to.revertedWith(
-      "GReputation: need minter role or be GDAO contract"
+      /GReputation: need minter role or be GDAO contract/
     );
   });
 
@@ -312,7 +312,7 @@ describe("GReputation", () => {
           ethers.utils.hexZeroPad("0xbadd", 32),
           ethers.utils.hexZeroPad("0xbadd", 32)
         )
-      ).to.revertedWith("GReputation::delegateBySig: invalid signature");
+      ).to.revertedWith(/GReputation::delegateBySig: invalid signature/);
     });
 
     it("It should not be delegate when delegation address is null", async () => {
@@ -353,7 +353,7 @@ describe("GReputation", () => {
       const sig = ethers.utils.splitSignature(signature);
       await expect(
         grep.delegateBySig(delegate, nonce, expiry, sig.v, sig.r, sig.s)
-      ).to.revertedWith("GReputation::delegateBySig: invalid nonce");
+      ).to.revertedWith(/GReputation::delegateBySig: invalid nonce/);
     });
 
     it("reverts if the signature has expired", async () => {
@@ -373,7 +373,7 @@ describe("GReputation", () => {
       const sig = ethers.utils.splitSignature(signature);
       await expect(
         grep.delegateBySig(delegate, nonce, expiry, sig.v, sig.r, sig.s)
-      ).to.revertedWith("GReputation::delegateBySig: signature expired");
+      ).to.revertedWith(/GReputation::delegateBySig: signature expired/);
     });
 
     describe("delegates on behalf of the signatory", () => {
@@ -588,7 +588,7 @@ describe("GReputation", () => {
       it("should set a new state hash", async () => {
         await expect(
           grep.setBlockchainStateHash("fuse", fuseHash, BN.from("100"))
-        ).to.be.revertedWith("only avatar can call this method");
+        ).to.be.revertedWith(/only avatar can call this method/);
 
         let encodedCall = grep.interface.encodeFunctionData(
           "setBlockchainStateHash",