@gooddollar/goodprotocol 1.0.29-beta.3 → 1.0.29-beta.5

package/test/faucet/Faucet.test.ts

@@ -0,0 +1,184 @@
+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;
 
@@ -25,7 +26,7 @@ describe("FuseFaucet", () => {
       avatar: av,
       gd: gooddollar,
       identity
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     Controller = controller;
     avatar = av;

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";
@@ -20,7 +21,7 @@ describe("ClaimersDistribution", () => {
     [root, acct, claimer1, claimer2, claimer3, ...signers] =
       await ethers.getSigners();
 
-    const deployedDAO = await createDAO();
+    const deployedDAO = await loadFixture(createDAO);
     let {
       nameService: ns,
       genericCall: gn,
@@ -49,7 +50,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");

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

@@ -1,4 +1,5 @@
 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";
@@ -30,7 +31,7 @@ describe("CompoundVotingMachine#CastVote", () => {
       setDAOAddress,
       nameService,
       votingMachine
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     gov = votingMachine;
     grep = (await ethers.getContractAt(
       "GReputation",
@@ -38,7 +39,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,4 +1,5 @@
 import hre, { 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";
@@ -69,7 +70,7 @@ describe("CompoundVotingMachine#DAOScheme", () => {
       nameService,
       votingMachine,
       genericCall: gc
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     Controller = controller;
     avatar = av;
     genericCall = gc;
@@ -82,7 +83,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]);

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

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { TypedDataUtils } from "ethers-eip712";
 import { expect } from "chai";
 // import { deployContract, deployMockContract, MockContract } from "ethereum-waffle";
@@ -69,7 +70,7 @@ describe("CompoundVotingMachine#Delegation", () => {
       setDAOAddress,
       nameService,
       votingMachine
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     grep = (await ethers.getContractAt(
       "GReputation",
       reputation
@@ -78,7 +79,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,4 +1,5 @@
 import hre, { 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";
@@ -60,7 +61,7 @@ describe("CompoundVotingMachine#Guardian", () => {
       genericCall,
       nameService: ns,
       votingMachine
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     Controller = controller;
     avatar = av;
@@ -75,7 +76,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]);

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]);

package/test/governance/GReputation.test.ts

@@ -1,6 +1,7 @@
 // import { GReputationInstance } from "../types/GReputation";
 import MerkleTree, { checkProofOrdered } from "merkle-tree-solidity";
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Signer } from "ethers";
 import { sign } from "crypto";
 import { expect } from "chai";
@@ -19,7 +20,7 @@ type BlockChainState = {
   blockNumber: BigNumber;
 };
 
-export const getMerkleAndProof = (data, proofIdx) => {
+export const getMerkleAndProof = async (data, proofIdx) => {
   const elements = data.map(e =>
     Buffer.from(
       ethers.utils
@@ -35,7 +36,7 @@ export const getMerkleAndProof = (data, proofIdx) => {
   );
 
   //this will give repOwner minter permissions
-  setDAOAddress("GDAO_CLAIMERS", repOwner);
+  await setDAOAddress("GDAO_CLAIMERS", repOwner);
 
   const merkleTree = new MerkleTree(elements, true);
 
@@ -78,7 +79,7 @@ describe("GReputation", () => {
       setDAOAddress: sda,
       avatar: av,
       genericCall
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     setDAOAddress = sda;
     avatar = av;
@@ -99,7 +100,7 @@ describe("GReputation", () => {
     // create merkle tree
     // expects unique 32 byte buffers as inputs (no hex strings)
     // if using web3.sha3, convert first -> Buffer(web3.sha3('a'), 'hex')
-    const merkleData = getMerkleAndProof(
+    const merkleData = await getMerkleAndProof(
       [
         [rep1, 1],
         [rep2, 2],
@@ -213,7 +214,7 @@ describe("GReputation", () => {
     });
 
     it("should allow multiple delegates", async () => {
-      const { merkleRoot, proof } = getMerkleAndProof(
+      const { merkleRoot, proof } = await getMerkleAndProof(
         [
           [rep1, 1],
           [rep2, 2],
@@ -396,7 +397,7 @@ describe("GReputation", () => {
 
   describe("setting a blockchain merkle hash", async () => {
     it("should set new merkle hash", async () => {
-      const { merkleRoot, proof } = getMerkleAndProof(
+      const { merkleRoot, proof } = await getMerkleAndProof(
         [
           [rep1, 100],
           [rep2, 200],
@@ -436,7 +437,7 @@ describe("GReputation", () => {
     it("should prove balance in new state", async () => {
       const prevRep = await grep.balanceOfLocal(rep2);
       const prevVotes = await grep.getVotes(rep2);
-      const { proof } = getMerkleAndProof(
+      const { proof } = await getMerkleAndProof(
         [
           [rep1, 100],
           [rep2, 200],
@@ -474,7 +475,7 @@ describe("GReputation", () => {
 
     it("should not effect delegate balance after new state hash", async () => {
       const prevDelegated = await grep.getVotes(rep3);
-      const { merkleRoot, proof } = getMerkleAndProof(
+      const { merkleRoot, proof } = await getMerkleAndProof(
         [
           [rep1, 100],
           [rep2, 200],
@@ -497,7 +498,7 @@ describe("GReputation", () => {
 
     it("should not effect delegate balance after new blockchain proof", async () => {
       const prevVotes = await grep.getVotes(rep3);
-      const { merkleRoot, proof } = getMerkleAndProof(
+      const { merkleRoot, proof } = await getMerkleAndProof(
         [
           [rep1, 100],
           [rep2, 200],
@@ -512,7 +513,7 @@ describe("GReputation", () => {
 
     it("should include own rep in votes balance after new state", async () => {
       const prevVotes = await grep.getVotes(rep3);
-      const { merkleRoot, proof } = getMerkleAndProof(
+      const { merkleRoot, proof } = await getMerkleAndProof(
         [
           [rep1, 100],
           [rep2, 200],
@@ -743,17 +744,21 @@ describe("GReputation", () => {
 
     it("it should be able to get totalSupplyLocal for particular block", async () => {
       let currentBlock = await ethers.provider.getBlockNumber();
-      const totalSupplyLocalBefore = await grep["totalSupplyLocal(uint256)"](currentBlock);
+      const totalSupplyLocalBefore = await grep["totalSupplyLocal(uint256)"](
+        currentBlock
+      );
       await grepWithOwner["mint(address,uint256)"](
         founder,
         ethers.utils.parseEther("1")
       );
       currentBlock = await ethers.provider.getBlockNumber();
-      const totalSupplyLocalAfter = await grep["totalSupplyLocal(uint256)"](currentBlock);
+      const totalSupplyLocalAfter = await grep["totalSupplyLocal(uint256)"](
+        currentBlock
+      );
       expect(totalSupplyLocalAfter).to.equal(
         totalSupplyLocalBefore.add(ethers.utils.parseEther("1"))
       );
-      
+
       await grepWithOwner["burn(address,uint256)"](
         founder,
         ethers.utils.parseEther("1")
@@ -870,7 +875,10 @@ describe("GReputation", () => {
       await advanceBlocks(1);
       await (await grepWithOwner["mint(address,uint256)"](rep2, 1)).wait();
       await advanceBlocks(1);
-      const priorSelectedBlockVotes = await grep.getPriorVotes(rep2, selectedBlock);
+      const priorSelectedBlockVotes = await grep.getPriorVotes(
+        rep2,
+        selectedBlock
+      );
       const votesAfterAdvancing = await grep.getCurrentVotes(rep2);
       expect(priorSelectedBlockVotes).to.eq(selectedBlockVotes);
       expect(priorSelectedBlockVotes).to.be.not.eq(votesAfterAdvancing);

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

@@ -1,4 +1,5 @@
 import { default as hre, ethers, upgrades, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { Contract, Signer } from "ethers";
 import { expect } from "chai";
 import {
@@ -65,7 +66,7 @@ describe("GoodDollarStaking - check fixed APY G$ rewards", () => {
       runAsAvatarOnly: ras,
       setSchemes: ss,
       genericCall: gc
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     setSchemes = ss;
     runAsAvatarOnly = ras;

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

@@ -1,4 +1,5 @@
 import { default as hre, ethers, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract, Signer } from "ethers";
 import { expect } from "chai";
 import { GoodReserveCDai, GReputation, GoodDollarStaking } from "../../types";
@@ -43,7 +44,7 @@ describe("GoodDollarStaking - check GOOD rewards based on GovernanceStaking.test
       cdaiAddress,
       reserve,
       reputation
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
     avatar = av;

package/test/governance/GovernanceStaking.test.ts

@@ -1,4 +1,5 @@
 import { default as hre, ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract, Signer } from "ethers";
 import { deployMockContract, MockContract } from "ethereum-waffle";
 import { expect } from "chai";
@@ -66,7 +67,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
       reserve,
       reputation,
       setReserveToken
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
     avatar = av;
@@ -111,8 +112,8 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
       nameService.address
     );
 
-    setDAOAddress("CDAI", cDAI.address);
-    setDAOAddress("DAI", dai.address);
+    await setDAOAddress("CDAI", cDAI.address);
+    await setDAOAddress("DAI", dai.address);
 
     //This set addresses should be another function because when we put this initialization of addresses in initializer then nameservice is not ready yet so no proper addresses
     await goodReserve.setAddresses();

package/test/governance/Reputation.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { Reputation } from "../../types";
 import { createDAO } from "../helpers";
@@ -10,7 +11,7 @@ describe("Reputation", () => {
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
 
-    let { nameService: ns, genericCall: gn } = await createDAO();
+    let { nameService: ns, genericCall: gn } = await loadFixture(createDAO);
     nameService = ns;
     genericCall = gn;
   });