@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

package/test/faucet/Faucet.test.ts

@@ -0,0 +1,157 @@
+import hre, { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { expect } from "chai";
+import { Faucet, IGoodDollar, IIdentity } from "../../types";
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
+import { createDAO } from "../helpers";
+
+const BN = ethers.BigNumber;
+
+describe("Faucet", () => {
+  let faucet: Faucet, founder: SignerWithAddress;
+  let user1 = ethers.Wallet.createRandom().connect(ethers.provider);
+  let user2 = ethers.Wallet.createRandom().connect(ethers.provider);
+  let signers;
+
+  let avatar, gd: IGoodDollar, Controller, id: IIdentity;
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+
+    const FuseFaucetF = await ethers.getContractFactory("Faucet");
+
+    let { daoCreator, controller, avatar: av, gd: gooddollar, identity, nameService } = await loadFixture(createDAO);
+
+    Controller = controller;
+    avatar = av;
+
+    // await daoCreator.setSchemes(
+    //   avatar,
+    //   [identity],
+    //   [ethers.constants.HashZero],
+    //   ["0x0000001F"],
+    //   ""
+    // );
+    //NameService _ns,
+    // uint64 _gasPrice,
+    // address relayer,
+    // address owner
+    faucet = (await upgrades.deployProxy(
+      FuseFaucetF,
+      [nameService.address, 1e10, signers[0].address, founder.address],
+      {
+        kind: "uups"
+      }
+    )) as Faucet;
+
+    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"),
+      to: faucet.address
+    });
+  });
+
+  it("should have balance", async () => {
+    const balance = await ethers.provider.getBalance(faucet.address);
+    expect(balance).to.equal(ethers.utils.parseEther("1"));
+  });
+
+  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");
+  });
+
+  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 balance = await ethers.provider.getBalance(user1.address);
+    expect(balance).to.equal(await faucet.toppingAmount());
+  });
+
+  it("should not let new user top more than once", async () => {
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      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"
+    );
+  });
+
+  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");
+    const balanceAfter = await ethers.provider.getBalance(founder.address);
+    const faucetBalanceAfter = await ethers.provider.getBalance(faucet.address);
+    expect(faucetBalanceAfter).to.eq(faucetBalance);
+    expect(balanceAfter).to.lt(balance);
+  });
+
+  it("should let user top again once identified", async () => {
+    await id.addWhitelistedWithDID(user1.address, "did:1");
+    expect(await faucet.canTop(user1.address)).to.true;
+    const tx = await (await faucet.topWallet(user1.address)).wait();
+    console.log(tx.gasUsed.toString());
+    const balance = await ethers.provider.getBalance(user1.address);
+    expect(balance).to.equal(await faucet.toppingAmount());
+  });
+
+  it("should not let identified user top over daily limit", async () => {
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.utils.parseUnits("400000", "gwei")
+    });
+    const tx = await (await faucet.topWallet(user1.address)).wait();
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      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");
+  });
+
+  // it("should not top if wallet not half empty", async () => {
+  //   expect(await faucet.canTop(founder.address)).to.false;
+  //   await expect(faucet.topWallet(founder.address)).to.revertedWith(
+  //     "User balance above minimum"
+  //   );
+  // });
+
+  it("should not let user top over weekly limit", async () => {
+    for (let i = 0; i < 5; i++) {
+      await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
+      await (await faucet.topWallet(user1.address)).wait();
+      await user1.sendTransaction({
+        to: ethers.constants.AddressZero,
+        value: ethers.utils.parseUnits("5000000", "gwei")
+      });
+    }
+    await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
+
+    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"
+    );
+
+    //should be able to top again after some days passed
+    await ethers.provider.send("evm_increaseTime", [60 * 60 * 24 * 3]);
+    await ethers.provider.send("evm_mine", []);
+
+    expect(await faucet.canTop(user1.address)).to.true;
+  });
+
+  it("should reimburse gas costs", async () => {
+    const balance = await ethers.provider.getBalance(founder.address);
+    const tx = await (await faucet.connect(signers[0]).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);
+    const diff = balance.sub(balanceAfter).toNumber();
+    expect(diff).to.lt(10000);
+  });
+});

package/test/{FuseFaucet.test.ts → faucet/FuseFaucet.test.ts}

@@ -1,8 +1,9 @@
 import hre, { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-import { FuseFaucet, IGoodDollar, IIdentity } from "../types";
+import { FuseFaucet, IGoodDollar, IIdentity } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
-import { createDAO } from "./helpers";
+import { createDAO } from "../helpers";
 
 const BN = ethers.BigNumber;
 
@@ -19,13 +20,7 @@ describe("FuseFaucet", () => {
 
     const FuseFaucetF = await ethers.getContractFactory("FuseFaucet");
 
-    let {
-      daoCreator,
-      controller,
-      avatar: av,
-      gd: gooddollar,
-      identity
-    } = await createDAO();
+    let { daoCreator, controller, avatar: av, gd: gooddollar, identity } = await loadFixture(createDAO);
 
     Controller = controller;
     avatar = av;
@@ -42,16 +37,8 @@ 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"),
@@ -59,6 +46,22 @@ describe("FuseFaucet", () => {
     });
   });
 
+  it("v1 should be upgradeable via old proxy method (for fuse)", async () => {
+    const FaucetV1 = await ethers.getContractFactory("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] }
+    });
+    expect(res).not.empty;
+    await expect(res.upgrade(signers[0].address, signers[0].address)).revertedWith("already upgraded");
+    expect(await res.owner()).equal(founder.address);
+    expect(await res.relayer()).equal(signers[1].address);
+  });
+
   it("should have balance", async () => {
     const balance = await ethers.provider.getBalance(faucet.address);
     expect(balance).to.equal(ethers.utils.parseEther("1"));
@@ -77,18 +80,14 @@ 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,9 +114,7 @@ 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 () => {
@@ -152,9 +149,7 @@ 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

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { ClaimersDistribution, GReputation } from "../../types";
 import { createDAO, deployUBI, advanceBlocks, increaseTime } from "../helpers";
@@ -16,11 +17,40 @@ describe("ClaimersDistribution", () => {
     ubiScheme,
     cd: ClaimersDistribution;
 
+  const regularTokenState = async () => {
+    const deployedDAO = await createDAO("regular");
+    let ubi = await deployUBI(deployedDAO, false);
+    const currentTime = (await ethers.provider.getBlock("latest")).timestamp;
+    if (currentTime % 2592000 > 2505600) {
+      await increaseTime(60 * 60 * 24);
+    }
+
+    if (currentTime % 86400 <= 43200) {
+      const increaseAmount = 50000 - (currentTime % 86400); // make sure that it passes noon
+      await increaseTime(increaseAmount);
+    }
+
+    const cd = (await upgrades.deployProxy(
+      await ethers.getContractFactory("ClaimersDistribution"),
+      [deployedDAO.nameService.address],
+      { kind: "uups" }
+    )) as ClaimersDistribution;
+
+    const ubiScheme = ubi.ubiScheme;
+    await deployedDAO.setDAOAddress("GDAO_CLAIMERS", cd.address);
+    await deployedDAO.addWhitelisted(claimer1.address, "claimer1");
+    await deployedDAO.addWhitelisted(claimer2.address, "claimer2");
+    await deployedDAO.addWhitelisted(claimer3.address, "claimer3");
+
+    await increaseTime(60 * 60 * 24);
+    return ubiScheme;
+  };
+
   before(async () => {
     [root, acct, claimer1, claimer2, claimer3, ...signers] =
       await ethers.getSigners();
 
-    const deployedDAO = await createDAO();
+    const deployedDAO = await loadFixture(createDAO);
     let {
       nameService: ns,
       genericCall: gn,
@@ -41,7 +71,7 @@ describe("ClaimersDistribution", () => {
       const increaseAmount = 50000 - (currentTime % 86400); // make sure that it passes noon
       await increaseTime(increaseAmount);
     }
-    let ubi = await deployUBI(deployedDAO);
+    let ubi = await deployUBI(deployedDAO, false);
     cd = (await upgrades.deployProxy(
       await ethers.getContractFactory("ClaimersDistribution"),
       [ns.address],
@@ -49,7 +79,7 @@ describe("ClaimersDistribution", () => {
     )) as ClaimersDistribution;
 
     ubiScheme = ubi.ubiScheme;
-    setDAOAddress("GDAO_CLAIMERS", cd.address);
+    await setDAOAddress("GDAO_CLAIMERS", cd.address);
     addWhitelisted(claimer1.address, "claimer1");
     await addWhitelisted(claimer2.address, "claimer2");
     await addWhitelisted(claimer3.address, "claimer3");
@@ -197,14 +227,36 @@ describe("ClaimersDistribution", () => {
     expect(endCount).to.be.equal(startCount.add(2));
   });
 
-  it("should not cost alot of gas to claim with reputation distribution [@skip-on-coverage]", async () => {
+  it("should cost alot of gas to claim with reputation distribution with superfluid [@skip-on-coverage]", async () => {
+    let totalGas = 0;
+    let gasCosts = {};
+    for (let i = 0; i < 31; i++) {
+      await increaseTime(60 * 60 * 24);
+      const tx = await (await ubiScheme.connect(claimer3).claim()).wait();
+      // const tx2 = await (await ubiScheme.connect(claimer2).claim()).wait();
+      gasCosts[tx.gasUsed.toString()] = true;
+      // gasCosts[tx2.gasUsed.toString()] = true;
+      totalGas += tx.gasUsed.toNumber();
+      // console.log({ totalGas }, tx.gasUsed.toNumber(), tx2.gasUsed.toNumber());
+    }
+    console.log(Object.keys(gasCosts));
+    expect(totalGas / 30).gt(480000);
+  });
+
+  it("should not cost alot of gas to claim with reputation distribution with regular token [@skip-on-coverage]", async () => {
+    const ubiScheme = await loadFixture(regularTokenState);
     let totalGas = 0;
+    let gasCosts = {};
     for (let i = 0; i < 31; i++) {
       await increaseTime(60 * 60 * 24);
       const tx = await (await ubiScheme.connect(claimer3).claim()).wait();
+      // const tx2 = await (await ubiScheme.connect(claimer2).claim()).wait();
+      gasCosts[tx.gasUsed.toString()] = true;
+      // gasCosts[tx2.gasUsed.toString()] = true;
       totalGas += tx.gasUsed.toNumber();
-      // console.log({ totalGas }, tx.gasUsed.toNumber());
+      // console.log({ totalGas }, tx.gasUsed.toNumber(), tx2.gasUsed.toNumber());
     }
-    expect(totalGas / 30).lt(310000);
+    console.log(Object.keys(gasCosts));
+    expect(totalGas / 30).lt(315000);
   });
 });

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

@@ -1,6 +1,6 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-// import { deployContract, deployMockContract, MockContract } from "ethereum-waffle";
 import { GReputation, CompoundVotingMachine } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
 import { createDAO } from "../helpers";
@@ -30,7 +30,7 @@ describe("CompoundVotingMachine#CastVote", () => {
       setDAOAddress,
       nameService,
       votingMachine
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     gov = votingMachine;
     grep = (await ethers.getContractAt(
       "GReputation",
@@ -38,7 +38,7 @@ describe("CompoundVotingMachine#CastVote", () => {
     )) as GReputation;
 
     //this will give root minter permissions
-    setDAOAddress("GDAO_CLAIMERS", root.address);
+    await setDAOAddress("GDAO_CLAIMERS", root.address);
 
     await grep.mint(root.address, ethers.BigNumber.from("1000000"));
     targets = [acct.address];

package/test/governance/CompoundVotingMachine.crossblockchain.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GReputation, CompoundVotingMachine } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
@@ -23,7 +24,7 @@ describe("CompoundVotingMachine#cross blockchain", () => {
     [root, acct, ...signers] = await ethers.getSigners();
 
     let { reputation, setDAOAddress, votingMachine, cdaiAddress, controller } =
-      await createDAO();
+      await loadFixture(createDAO);
     testaddr = controller;
     grep = (await ethers.getContractAt(
       "GReputation",
@@ -33,7 +34,7 @@ describe("CompoundVotingMachine#cross blockchain", () => {
     gov = votingMachine;
 
     //this will give root minter permissions
-    setDAOAddress("GDAO_CLAIMERS", root.address);
+    await setDAOAddress("GDAO_CLAIMERS", root.address);
 
     await grep.mint(root.address, ethers.BigNumber.from("1000000"));
     targets = [root.address];

package/test/governance/CompoundVotingMachine.daoscheme.ts

@@ -1,10 +1,8 @@
-import hre, { ethers, upgrades } from "hardhat";
+import hre, { ethers } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-// import { deployContract, deployMockContract, MockContract } from "ethereum-waffle";
 import { GReputation, CompoundVotingMachine } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
-import { Wallet } from "ethers";
-import { deployMockContract, MockContract } from "ethereum-waffle";
 import { createDAO } from "../helpers";
 
 const BN = ethers.BigNumber;
@@ -69,7 +67,7 @@ describe("CompoundVotingMachine#DAOScheme", () => {
       nameService,
       votingMachine,
       genericCall: gc
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     Controller = controller;
     avatar = av;
     genericCall = gc;
@@ -82,7 +80,7 @@ describe("CompoundVotingMachine#DAOScheme", () => {
     setAddress = setDAOAddress;
 
     //this will give root minter permissions
-    setDAOAddress("GDAO_CLAIMERS", root.address);
+    await setDAOAddress("GDAO_CLAIMERS", root.address);
 
     //set voting machiine as scheme with permissions
     await setSchemes([gov.address]);
@@ -91,10 +89,6 @@ describe("CompoundVotingMachine#DAOScheme", () => {
     await grep.mint(acct.address, ethers.BigNumber.from("500000"));
 
     queuePeriod = await gov.queuePeriod().then(_ => _.toNumber());
-
-    let mockABI = ["function rec() payable"];
-    mock = await deployMockContract(root, mockABI);
-    mock.mock.rec.returns();
   });
 
   ///cell 0 - votingPeriod blocks, 1 - quoromPercentage, 2 - proposalPercentage,3 - proposalMaxOperations, 4 - voting delay blocks, 5 - queuePeriod time
@@ -256,6 +250,10 @@ describe("CompoundVotingMachine#DAOScheme", () => {
   });
 
   it("Should use value passed to execute", async () => {
+    const mock = await (
+      await ethers.getContractFactory("PayableMock")
+    ).deploy();
+
     let wallet = ethers.Wallet.createRandom();
     let targets = [mock.address];
     let values = [ethers.utils.parseEther("10")];

package/test/governance/CompoundVotingMachine.delegate.test.ts

@@ -1,7 +1,6 @@
-import { ethers, upgrades } from "hardhat";
-import { TypedDataUtils } from "ethers-eip712";
+import { ethers } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-// import { deployContract, deployMockContract, MockContract } from "ethereum-waffle";
 import { GReputation, CompoundVotingMachine } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
 import { createDAO } from "../helpers";
@@ -69,7 +68,7 @@ describe("CompoundVotingMachine#Delegation", () => {
       setDAOAddress,
       nameService,
       votingMachine
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     grep = (await ethers.getContractAt(
       "GReputation",
       reputation
@@ -78,7 +77,7 @@ describe("CompoundVotingMachine#Delegation", () => {
     gov = votingMachine;
 
     //this will give root minter permissions
-    setDAOAddress("GDAO_CLAIMERS", root.address);
+    await setDAOAddress("GDAO_CLAIMERS", root.address);
 
     await grep.mint(root.address, ethers.BigNumber.from("1000000"));
     await grep.mint(acct.address, ethers.BigNumber.from("500000"));

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

@@ -1,10 +1,8 @@
-import hre, { ethers, upgrades } from "hardhat";
+import hre, { ethers, upgrades, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-// import { deployContract, deployMockContract, MockContract } from "ethereum-waffle";
 import { GReputation, CompoundVotingMachine } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
-import { Wallet } from "ethers";
-import { deployMockContract, MockContract } from "ethereum-waffle";
 import { createDAO, increaseTime } from "../helpers";
 
 const BN = ethers.BigNumber;
@@ -45,7 +43,7 @@ describe("CompoundVotingMachine#Guardian", () => {
     acct: SignerWithAddress;
 
   let queuePeriod, avatarGenericCall;
-  let avatar, mock, Controller;
+  let avatar, Controller;
 
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
@@ -60,7 +58,7 @@ describe("CompoundVotingMachine#Guardian", () => {
       genericCall,
       nameService: ns,
       votingMachine
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     Controller = controller;
     avatar = av;
@@ -75,7 +73,7 @@ describe("CompoundVotingMachine#Guardian", () => {
     gov = votingMachine;
 
     //this will give root minter permissions
-    setDAOAddress("GDAO_CLAIMERS", root.address);
+    await setDAOAddress("GDAO_CLAIMERS", root.address);
 
     //set voting machiine as scheme with permissions
     await setSchemes([gov.address]);
@@ -84,10 +82,6 @@ describe("CompoundVotingMachine#Guardian", () => {
     await grep.mint(acct.address, ethers.BigNumber.from("500000"));
 
     queuePeriod = await gov.queuePeriod().then(_ => _.toNumber());
-
-    let mockABI = ["function rec() payable"];
-    mock = await deployMockContract(root, mockABI);
-    mock.mock.rec.returns();
   });
 
   it("should set guardian from initializer", async () => {

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

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GReputation, CompoundVotingMachine } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
@@ -24,7 +25,7 @@ describe("CompoundVotingMachine#propose", () => {
     [root, acct, ...signers] = await ethers.getSigners();
 
     let { avatar, reputation, setDAOAddress, nameService, votingMachine } =
-      await createDAO();
+      await loadFixture(createDAO);
 
     grep = (await ethers.getContractAt(
       "GReputation",
@@ -34,7 +35,7 @@ describe("CompoundVotingMachine#propose", () => {
     gov = votingMachine;
 
     //this will give root minter permissions
-    setDAOAddress("GDAO_CLAIMERS", root.address);
+    await setDAOAddress("GDAO_CLAIMERS", root.address);
 
     await grep.mint(root.address, ethers.BigNumber.from("1000000"));
     targets = [root.address];

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

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GReputation, CompoundVotingMachine } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
@@ -66,7 +67,7 @@ describe("CompoundVotingMachine#States", () => {
       setDAOAddress,
       nameService,
       votingMachine
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     grep = (await ethers.getContractAt(
       "GReputation",
@@ -76,7 +77,7 @@ describe("CompoundVotingMachine#States", () => {
     gov = votingMachine;
 
     //this will give root minter permissions
-    setDAOAddress("GDAO_CLAIMERS", root.address);
+    await setDAOAddress("GDAO_CLAIMERS", root.address);
 
     //set voting machiine as scheme with permissions
     await setSchemes([gov.address]);