@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

package/test/invite/InvitesV2.test.ts

@@ -0,0 +1,328 @@
+import hre, { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { expect } from "chai";
+import { InvitesV2, IGoodDollar, IIdentity, IdentityV2 } from "../../types";
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
+import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
+
+import { createDAO } from "../helpers";
+
+const BN = ethers.BigNumber;
+
+describe("InvitesV2", () => {
+  let invites: InvitesV2, founder: SignerWithAddress;
+  let inviter1, inviter2, invitee1, invitee2, invitee3, invitee4, invitee5, invitee6, invitee7, invitee8;
+
+  let avatar, gd: IGoodDollar, Controller, id: IdentityV2, setDAOAddress, setSchemes;
+
+  const initialState = async () => {};
+  before(async () => {
+    [founder, inviter1, inviter2, invitee1, invitee2, invitee3, invitee4, invitee5, invitee6, invitee7, invitee8] =
+      await ethers.getSigners();
+
+    const InvitesV2 = await ethers.getContractFactory("InvitesV2");
+
+    let {
+      controller,
+      avatar: av,
+      gd: gooddollar,
+      identity,
+      nameService,
+      setDAOAddress: sda,
+      setSchemes: sc
+    } = await loadFixture(createDAO);
+
+    Controller = controller;
+    avatar = av;
+    setDAOAddress = sda;
+    setSchemes = sc;
+
+    invites = (await upgrades.deployProxy(InvitesV2, [nameService.address, 500, founder.address], {
+      kind: "uups"
+    })) as InvitesV2;
+
+    gd = (await ethers.getContractAt("IGoodDollar", gooddollar, founder)) as IGoodDollar;
+    id = (await ethers.getContractAt("IdentityV2", identity, founder)) as IdentityV2;
+
+    await gd["mint(address,uint256)"](invites.address, BN.from(5000));
+    await loadFixture(initialState);
+    // await gd.transfer(invites.address, BN.from(5000));
+  });
+
+  it("v1 should be upgradeable via old proxy method", async () => {
+    const InvitesV1 = await ethers.getContractFactory("InvitesV1");
+    const invites = await upgrades.deployProxy(InvitesV1, [avatar, id.address, gd.address, 500], {
+      kind: "transparent"
+    });
+    const res = await upgrades.upgradeProxy(invites.address, await ethers.getContractFactory("InvitesFuseV2"), {
+      kind: "transparent",
+      unsafeAllowRenames: true
+    });
+    expect(res).not.empty;
+  });
+
+  it("should have balance", async () => {
+    const balance = await gd.balanceOf(invites.address);
+    expect(balance).to.equal(5000);
+  });
+
+  it("should have version", async () => {
+    expect(await invites.active()).to.be.true;
+    const version = await invites.version();
+    expect(version).to.be.equal("2.1");
+  });
+
+  it("should let anyone join", async () => {
+    await invites.connect(inviter1).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+    let inviter = await invites.users(inviter1.address);
+    expect(inviter.inviteCode).to.equal(ethers.utils.hexZeroPad("0xfa", 32));
+  });
+
+  it("should allow to join only once", async () => {
+    await expect(
+      invites.connect(inviter1).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.utils.hexZeroPad("0x01", 32))
+    ).to.revertedWith("user already joined");
+  });
+
+  it("should not allow code reuse", async () => {
+    // const invites = await Invites.deployed();
+    await expect(
+      invites.connect(inviter2).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero)
+    ).to.revertedWith("invite code already in use");
+  });
+
+  it("should mark inviter", async () => {
+    await invites.connect(invitee1).join(ethers.utils.hexZeroPad("0xaa", 32), ethers.utils.hexZeroPad("0xfa", 32));
+    let invitee = await invites.users(invitee1.address);
+    let inviterInvitees = await invites.getInvitees(inviter1.address);
+    expect(invitee.invitedBy).to.be.equal(inviter1.address);
+    expect(inviterInvitees).to.include(invitee1.address);
+  });
+
+  it("should not pay bounty for non whitelisted invitee", async () => {
+    await expect(invites.connect(inviter1).bountyFor(invitee1.address)).to.revertedWith(
+      "user not elligble for bounty yet"
+    );
+  });
+
+  it("should not allow to pay bounty for non whitelisted inviter", async () => {
+    await id.addWhitelistedWithDID(invitee1.address, Math.random() + "");
+    expect(await id.isWhitelisted(invitee1.address)).to.be.true;
+    expect(await id.isWhitelisted(inviter1.address)).to.be.false;
+    expect(await id.getWhitelistedOnChainId(invitee1.address)).eq(4447);
+    expect(await invites.canCollectBountyFor(invitee1.address)).to.be.false;
+    await expect(invites.bountyFor(invitee1.address)).reverted;
+  });
+
+  it("should pay bounty for whitelisted invitee and inviter", async () => {
+    const bounty = (await invites.levels(0)).bounty.toNumber();
+    await id.addWhitelistedWithDID(inviter1.address, Math.random() + "").catch(e => e);
+    const startBalance = await gd.balanceOf(inviter1.address).then(_ => _.toNumber());
+    expect(await id.isWhitelisted(inviter1.address)).to.be.true;
+    let pending = await invites.getPendingInvitees(inviter1.address);
+    expect(pending.length, "pending").to.be.equal(1);
+    const inviteeBalance = await gd.balanceOf(invitee1.address).then(_ => _.toNumber());
+    await invites.connect(inviter1).bountyFor(invitee1.address);
+
+    let invitee = await invites.users(invitee1.address);
+    let inviter = await invites.users(inviter1.address);
+    const endBalance = await gd.balanceOf(inviter1.address).then(_ => _.toNumber());
+
+    pending = await invites.getPendingInvitees(inviter1.address);
+    const txFee = await gd["getFees(uint256)"](bounty).then(_ => _["0"].toNumber()); //gd might have a tx fee
+    const txFee2 = await gd["getFees(uint256)"](bounty / 2).then(_ => _["0"].toNumber()); //gd might have a tx fee
+
+    expect(pending.length, "pending").to.be.equal(0);
+    expect(invitee.bountyPaid).to.be.true;
+    expect(inviter.totalApprovedInvites.toNumber()).to.be.equal(1);
+    expect(inviter.totalEarned.toNumber()).to.be.equal(bounty);
+    expect(endBalance - startBalance + txFee, "inviter rewards not matching bounty").to.be.equal(bounty);
+    expect(
+      (await gd.balanceOf(invitee1.address).then(_ => _.toNumber())) - inviteeBalance,
+      "invitee rewrad should be bounty/2"
+    ).to.be.equal(bounty / 2 - txFee2); //test that invitee  got half bonus
+  });
+
+  it("should update global stats", async () => {
+    const bounty = (await invites.levels(0)).bounty.toNumber();
+    const stats = await invites.stats();
+    expect(stats.totalApprovedInvites.toNumber()).to.be.equal(1, "approved invites");
+    expect(stats.totalInvited.toNumber()).to.be.equal(1, "total  invited");
+    expect(stats.totalBountiesPaid.toNumber()).to.be.equal(bounty);
+  });
+
+  it("should not pay bounty twice", async () => {
+    await expect(invites.connect(inviter2).bountyFor(invitee1.address)).to.revertedWith(
+      "user not elligble for bounty yet"
+    );
+  });
+
+  it("should not fail in collectBounties for invalid invitees", async () => {
+    await invites.connect(invitee7).join(ethers.utils.hexZeroPad("0x01", 32), ethers.utils.hexZeroPad("0xfa", 32));
+    await invites.connect(invitee8).join(ethers.utils.hexZeroPad("0x02", 32), ethers.utils.hexZeroPad("0xfa", 32));
+
+    let pending = await invites.getPendingInvitees(inviter1.address);
+    expect(pending.length, "pending").to.be.equal(2);
+    await expect(invites.connect(inviter1).collectBounties()).to.not.reverted;
+    let user1 = await invites.users(invitee7.address);
+    let user2 = await invites.users(invitee8.address);
+    pending = await invites.getPendingInvitees(inviter1.address);
+    expect(await invites.getPendingBounties(inviter1.address).then(_ => _.toNumber())).to.be.equal(0);
+    expect(user1.bountyPaid).to.be.false;
+    expect(user2.bountyPaid).to.be.false;
+    expect(pending.length, "pending").to.be.equal(2);
+  });
+
+  it("should collectBounties for inviter", async () => {
+    await id.addWhitelistedWithDID(invitee7.address, Math.random() + "");
+    await id.addWhitelistedWithDID(invitee8.address, Math.random() + "");
+    expect(await invites.getPendingBounties(inviter1.address).then(_ => _.toNumber())).to.be.equal(2);
+    const res = await invites.connect(inviter1).collectBounties();
+
+    let user1 = await invites.users(invitee7.address);
+    let user2 = await invites.users(invitee8.address);
+    let pending = await invites.getPendingInvitees(inviter1.address);
+    expect(await invites.getPendingBounties(inviter1.address).then(_ => _.toNumber())).to.be.equal(0);
+    expect(pending.length, "pending").to.be.equal(0);
+    expect(user1.bountyPaid, "user1").to.be.true;
+    expect(user2.bountyPaid, "user2").to.be.true;
+  });
+
+  it("should not set level not by owner", async () => {
+    await expect(invites.connect(inviter1).setLevel(0, 1, 5, 1)).to.revertedWith(
+      "Only owner or avatar can perform this action"
+    );
+  });
+
+  it("should set level by owner", async () => {
+    await invites.setLevel(0, 1, 5, 1);
+    let lvl = await invites.levels(0);
+    expect(lvl.toNext.toNumber()).to.be.equal(1);
+    expect(lvl.daysToComplete.toNumber()).to.be.equal(1);
+    await invites.setLevel(1, 0, 10, 2);
+    lvl = await invites.levels(1);
+    expect(lvl.toNext.toNumber()).to.be.equal(0);
+    expect(lvl.daysToComplete.toNumber()).to.be.equal(2);
+    expect(lvl.bounty.toNumber()).to.be.equal(10);
+  });
+
+  it("should update inviter level", async () => {
+    await invites
+      .connect(inviter1)
+      .join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero)
+      .then(_ => _.wait())
+      .catch(e => e);
+
+    await id.addWhitelistedWithDID(inviter1.address, Math.random() + "").catch(e => e);
+    await invites.setLevel(0, 1, 5, 1); //1 inviter to level up
+    await invites.setLevel(1, 0, 10, 2); // 10 bounty for second level
+
+    await invites.connect(invitee4).join(ethers.utils.hexZeroPad("0x03", 32), ethers.utils.hexZeroPad("0xfa", 32));
+    await invites.connect(invitee5).join(ethers.utils.hexZeroPad("0x04", 32), ethers.utils.hexZeroPad("0xfa", 32));
+    await id.addWhitelistedWithDID(invitee4.address, Math.random() + "").catch(e => e);
+    await id.addWhitelistedWithDID(invitee5.address, Math.random() + "").catch(e => e);
+    const res1 = await (await invites.bountyFor(invitee4.address)).wait();
+
+    const log1 = res1.events.find(_ => _.event === "InviterBounty");
+    expect(log1.event).to.be.equal("InviterBounty");
+    expect(log1.args.inviterLevel.toNumber()).to.be.equal(1);
+    expect(log1.args.earnedLevel).to.be.equal(true);
+    expect(log1.args.bountyPaid.toNumber()).to.be.equal(5);
+
+    let inviter = await invites.users(inviter1.address);
+    expect(inviter.level.toNumber()).to.be.equal(1);
+    const res2 = await (await invites.connect(inviter1).collectBounties()).wait();
+    const log2 = res2.events.find(_ => _.event === "InviterBounty");
+    expect(log2.event).to.be.equal("InviterBounty");
+    expect(log2.args.inviterLevel.toNumber()).to.be.equal(1);
+    expect(log2.args.earnedLevel).to.be.equal(false);
+    expect(log2.args.bountyPaid.toNumber()).to.be.equal(10);
+  });
+
+  it("should allow to set inviter later and pay bounty", async () => {
+    await invites.connect(invitee6).join(ethers.utils.hexZeroPad("0xfd", 32), ethers.constants.HashZero);
+    await invites.connect(invitee6).join(ethers.utils.hexZeroPad("0xfd", 32), ethers.utils.hexZeroPad("0xfa", 32));
+    const invitee = await invites.users(invitee6.address);
+    expect(invitee.invitedBy).to.equal(inviter1.address);
+    await id.addWhitelistedWithDID(invitee6.address, Math.random() + "").catch(e => e);
+    await expect(invites.bountyFor(invitee6.address)).to.emit(invites, "InviterBounty");
+  });
+
+  describe("MultiChain", () => {
+    it("should not revert if old identity contract without getWhitelistedOnChain", async () => {
+      await loadFixture(initialState);
+      const contractFactory = new ethers.ContractFactory(IdentityABI.abi, IdentityABI.bytecode, founder);
+      const oldId = await contractFactory.deploy();
+      await oldId.setAvatar(avatar);
+      await setSchemes([oldId.address], []);
+      await setDAOAddress("IDENTITY", oldId.address);
+
+      expect(await invites.getIdentity()).equal(oldId.address);
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+
+      await invites.connect(invitee2).join(ethers.utils.hexZeroPad("0xaa", 32), ethers.utils.hexZeroPad("0xfa", 32));
+
+      await oldId.addWhitelistedWithDID(invitee2.address, Math.random() + "");
+      await oldId.addWhitelistedWithDID(inviter1.address, Math.random() + "");
+      await invites.connect(inviter1).bountyFor(invitee2.address);
+    });
+
+    it("should always be able to use my address as invite code", async () => {
+      await loadFixture(initialState);
+
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad(inviter1.address, 32), ethers.constants.HashZero);
+
+      await expect(
+        invites.connect(inviter2).join(ethers.utils.hexZeroPad(inviter2.address, 32), ethers.constants.HashZero)
+      ).not.reverted;
+
+      await expect(
+        invites.connect(inviter1).join(ethers.utils.hexZeroPad(inviter1.address, 32), ethers.constants.HashZero)
+      ).reverted;
+    });
+
+    it("should not allow to claim if whitelisted originally on another chain", async () => {
+      await loadFixture(initialState);
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+      await invites.connect(invitee2).join(ethers.utils.hexZeroPad("0xaa", 32), ethers.utils.hexZeroPad("0xfa", 32));
+
+      await id.addWhitelistedWithDIDAndChain(invitee2.address, Math.random() + "", 122, 0);
+      expect(await id.getWhitelistedOnChainId(invitee2.address)).equal(122);
+      await expect(invites.connect(inviter1).bountyFor(invitee2.address)).to.revertedWith(
+        "user not elligble for bounty yet"
+      );
+    });
+
+    it("should allow to claim if whitelisted originally on same chain", async () => {
+      await loadFixture(initialState);
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+      await invites.connect(invitee2).join(ethers.utils.hexZeroPad("0xaa", 32), ethers.utils.hexZeroPad("0xfa", 32));
+
+      await id.addWhitelistedWithDID(inviter1.address, Math.random() + "");
+
+      await id.addWhitelistedWithDIDAndChain(invitee2.address, Math.random() + "", 4447, 0);
+      expect(await id.getWhitelistedOnChainId(invitee2.address)).equal(4447);
+      await expect(invites.connect(inviter1).bountyFor(invitee2.address)).not.reverted;
+    });
+
+    it("should pay bounty on join for whitelisted invitee and inviter", async () => {
+      await loadFixture(initialState);
+      await id.addWhitelistedWithDID(inviter1.address, Math.random() + "").catch(e => e);
+      await id.addWhitelistedWithDID(invitee1.address, Math.random() + "").catch(e => e);
+
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad(inviter1.address, 32), ethers.constants.HashZero);
+      const tx = await invites
+        .connect(invitee1)
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.utils.hexZeroPad(inviter1.address, 32));
+      const { events } = await tx.wait();
+      const bountyEvent = events.find(_ => _.event === "InviterBounty");
+      expect(bountyEvent).not.empty;
+    });
+  });
+
+  it("should end contract by owner", async () => {
+    expect(await gd.balanceOf(invites.address).then(_ => _.toNumber())).to.be.gt(0);
+    await invites.end();
+    expect(await gd.balanceOf(invites.address).then(_ => _.toNumber())).to.be.eq(0);
+  });
+});

package/test/reserve/DistributionHelper.test.ts

@@ -1,4 +1,5 @@
 import { ethers, waffle, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import {
   GoodReserveCDai,
@@ -40,7 +41,7 @@ describe("DistributionHelper", () => {
       cdaiAddress,
       genericCall: gc,
       nameService: ns
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     nameService = ns;
     genericCall = gc;

package/test/reserve/GoodMarketMaker.test.ts

@@ -1,5 +1,5 @@
-import { default as hre, ethers, upgrades } from "hardhat";
-import { deployMockContract, MockContract } from "ethereum-waffle";
+import { default as hre, ethers, upgrades, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GoodMarketMaker, CERC20 } from "../../types";
 import { createDAO, increaseTime } from "../helpers";
@@ -24,26 +24,19 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     fakeReserve;
 
   const deployDAIMock = async () => {
-    let [signer] = await ethers.getSigners();
-    let cdai = await hre.artifacts.readArtifact("cERC20");
-    let dai = await deployMockContract(signer, cdai.abi);
-    dai.mock.decimals.returns(18);
+    let dai = await (await ethers.getContractFactory("DAIMock")).deploy();
 
     return dai.address;
   };
 
   const deploycDAIMock = async () => {
-    let [signer] = await ethers.getSigners();
-    let cdai = await hre.artifacts.readArtifact("cERC20");
-    let dai = await deployMockContract(signer, cdai.abi);
-    dai.mock.decimals.returns(8);
-    return dai.address;
+    let cdai = await (await ethers.getContractFactory("cDAIMock")).deploy(dai);
+
+    return cdai.address;
   };
 
   before(async () => {
     [founder, staker, fakeReserve, ...signers] = await ethers.getSigners();
-    cdai = await deploycDAIMock();
-    dai = await deployDAIMock();
 
     let {
       controller: ctrl,
@@ -56,7 +49,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       setSchemes,
       setReserveToken,
       setDAOAddress
-    } = await createDAO();
+    } = await loadFixture(createDAO);
     avatar = av;
     marketMaker = mm.connect(fakeReserve);
     controller = ctrl;
@@ -64,9 +57,12 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
 
     console.log("deployed dao", { goodDollar, identity, controller, avatar });
 
+    dai = await deployDAIMock();
+    cdai = await deploycDAIMock();
+
     //give founder generic call permission
     await setSchemes([founder.address]);
-    setDAOAddress("RESERVE", fakeReserve.address);
+    await setDAOAddress("RESERVE", fakeReserve.address);
     console.log("starting tests...");
   });
 
@@ -600,12 +596,17 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
 
   it("should not set reserve ratio daily expansion with illigal values", async () => {
     const invalidZeroDenominator = 0;
-    await expect(marketMaker.setReserveRatioDailyExpansion(1, invalidZeroDenominator)).to.be.
-      revertedWith("denominator must be above 0");
+    await expect(
+      marketMaker.setReserveRatioDailyExpansion(1, invalidZeroDenominator)
+    ).to.be.revertedWith("denominator must be above 0");
 
     const denominator = 1;
     const nominatorHigherThanDenom = 2;
-    await expect(marketMaker.setReserveRatioDailyExpansion(nominatorHigherThanDenom, denominator)).to.be.
-      revertedWith("Invalid nom or denom value");
+    await expect(
+      marketMaker.setReserveRatioDailyExpansion(
+        nominatorHigherThanDenom,
+        denominator
+      )
+    ).to.be.revertedWith("Invalid nom or denom value");
   });
 });

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

@@ -1,4 +1,5 @@
 import { default as hre, ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GoodMarketMaker, CERC20, GoodReserveCDai } from "../../types";
 import { createDAO, increaseTime, advanceBlocks } from "../helpers";
@@ -36,7 +37,7 @@ describe("GoodReserve - Enforce token cap", () => {
       marketMaker: mm,
       reserve,
       cdaiAddress
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     cDai = cdaiAddress;
     avatar = av;
@@ -111,6 +112,12 @@ describe("GoodReserve - Enforce token cap", () => {
       .connect(founder)
       .mintRewardFromRR(cDai, founder.address, 10);
     expect(await goodDollar.balanceOf(founder.address)).to.equal(1020);
+
+    encodedCall = goodDollar.interface.encodeFunctionData("addMinter", [
+      avatar
+    ]);
+
+    await ictrl.genericCall(goodDollar.address, encodedCall, avatar, 0);
   });
 
   it("should not be able to mint if not core contract and GoodReserve is minter", async () => {

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

@@ -1,4 +1,5 @@
 import { ethers, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GoodReserveCDai, DistributionHelper } from "../../types";
 import { createDAO, increaseTime } from "../helpers";
@@ -34,7 +35,7 @@ describe("GoodReserve - Distribution Helper", () => {
       cdaiAddress,
       genericCall: gc,
       nameService: ns
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     nameService = ns;
     genericCall = gc;

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

@@ -1,6 +1,6 @@
 import { default as hre, ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Signer } from "ethers";
-import { deployMockContract, MockContract } from "ethereum-waffle";
 import { expect } from "chai";
 import { GoodMarketMaker, CERC20, GoodReserveCDai } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
@@ -50,7 +50,7 @@ describe("GDX Token", () => {
       cdaiAddress,
       genericCall: gn,
       runAsAvatarOnly: raao
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);

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

@@ -1,4 +1,5 @@
 import { ethers, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GoodReserveCDai, DistributionHelper } from "../../types";
 import { createDAO, increaseTime } from "../helpers";
@@ -34,7 +35,7 @@ describe("GoodReserve - Distribution Helper", () => {
       daiAddress,
       cdaiAddress,
       genericCall: gc
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);

package/test/reserve/GoodReserveCDai.test.ts

@@ -1,12 +1,10 @@
 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";
-import { GoodMarketMaker, CERC20, GoodReserveCDai } from "../../types";
-import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
+import { GoodMarketMaker } from "../../types";
 import { createDAO, increaseTime, advanceBlocks } from "../helpers";
 import ContributionCalculation from "@gooddollar/goodcontracts/stakingModel/build/contracts/ContributionCalculation.json";
-import { parseUnits } from "@ethersproject/units";
 
 const BN = ethers.BigNumber;
 export const NULL_ADDRESS = ethers.constants.AddressZero;
@@ -48,8 +46,8 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       daiAddress,
       cdaiAddress,
       reserve,
-      runAsAvatarOnly: raao,
-    } = await createDAO();
+      runAsAvatarOnly: raao
+    } = await loadFixture(createDAO);
 
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
@@ -86,7 +84,6 @@ describe("GoodReserve - staking with cDAI mocks", () => {
 
     marketMaker = mm;
 
-    const reserveFactory = await ethers.getContractFactory("GoodReserveCDai");
     console.log("deployed contribution, deploying reserve...", {
       founder: founder.address
     });
@@ -117,26 +114,8 @@ describe("GoodReserve - staking with cDAI mocks", () => {
 
   it("should set fundManager in the reserve by avatar", async () => {
     await setDAOAddress("FUND_MANAGER", founder.address);
-    // const rFactory = await ethers.getContractFactory("GoodReserveCDai");
-    // const ctrl = await ethers.getContractAt(
-    //   "Controller",
-    //   controller,
-    //   schemeMock
-    // );
-    // const encodedCall = rFactory.interface.encodeFunctionData(
-    //   "setFundManager",
-    //   [founder.address]
-    // );
-    // await ctrl.genericCall(goodReserve.address, encodedCall, avatar, 0);
-    // const newFM = await goodReserve.fundManager();
-    // expect(newFM.toString()).to.be.equal(founder.address);
   });
 
-  // it("should returned true for isActive", async () => {
-  //   const isActive = await goodReserve.isActive();
-  //   expect(isActive.toString()).to.be.equal("true");
-  // });
-
   it("should returned fixed 0.0001 market price", async () => {
     const gdPrice = await goodReserve["currentPrice()"]();
     const cdaiWorthInGD = gdPrice.mul(BN.from("100000000"));
@@ -423,9 +402,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     let error = await exchangeHelper
       .buy([cDAI.address], amount, 0, 0, NULL_ADDRESS)
       .catch(e => e);
-    expect(error.message).to.have.string(
-      "ERC20: transfer amount exceeds allowance"
-    );
+    expect(error.message).to.have.string("ERC20: insufficient allowance");
   });
 
   it("should not be able to buy gd without enough cDAI funds", async () => {
@@ -906,9 +883,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     let amount = 1e8;
     await cDAI.approve(goodReserve.address, 0);
     const tx = await goodReserve.buy(amount, 0, founder.address).catch(e => e);
-    expect(tx.message).to.have.string(
-      "ERC20: transfer amount exceeds allowance"
-    );
+    expect(tx.message).to.have.string("ERC20: insufficient allowance");
   });
   it("should be able to sell gd directly through reserve", async () => {
     const cdaiBalanceBeforeSell = await cDAI.balanceOf(founder.address);
@@ -1139,22 +1114,23 @@ describe("GoodReserve - staking with cDAI mocks", () => {
 
     await runAsAvatarOnly(
       goodReserve,
-      "setReserveRatioDailyExpansion(uint256,uint256)", 
-      1, 
+      "setReserveRatioDailyExpansion(uint256,uint256)",
+      1,
       1e15
     );
 
     let newReserveRatioDailyExpansion =
       await marketMaker.reserveRatioDailyExpansion();
     console.log(newReserveRatioDailyExpansion.toString());
-    
-    expect(newReserveRatioDailyExpansion).to.not.equal(currentReserveRatioDailyExpansion);
+
+    expect(newReserveRatioDailyExpansion).to.not.equal(
+      currentReserveRatioDailyExpansion
+    );
     expect(newReserveRatioDailyExpansion).to.be.equal(BN.from("1000000000000"));
 
     const encodedCall = goodReserve.interface.encodeFunctionData(
-      "setReserveRatioDailyExpansion", 
-      [BN.from(currentReserveRatioDailyExpansion).div(1e12),
-      1e15]
+      "setReserveRatioDailyExpansion",
+      [BN.from(currentReserveRatioDailyExpansion).div(1e12), 1e15]
     );
     const ctrl = await ethers.getContractAt(
       "Controller",