@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

package/test/reserve/GoodReserveCDai.uniswap.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 import { GoodMarketMaker, GoodReserveCDai } from "../../types";
@@ -43,6 +44,24 @@ describe("GoodReserve - buy/sell with any token through uniswap", () => {
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
+
+    let {
+      controller: ctrl,
+      avatar: av,
+      gd,
+      identity,
+      daoCreator,
+      nameService: ns,
+      setDAOAddress: sda,
+      setSchemes,
+      marketMaker: mm,
+      daiAddress,
+      cdaiAddress,
+      reserve,
+      setReserveToken,
+      COMP
+    } = await loadFixture(createDAO);
+
     const cdaiFactory = await ethers.getContractFactory("cDAIMock");
     const daiFactory = await ethers.getContractFactory("DAIMock");
     const routerFactory = new ethers.ContractFactory(
@@ -69,23 +88,6 @@ describe("GoodReserve - buy/sell with any token through uniswap", () => {
 
     tokenB = await daiFactory.deploy(); // another erc20 for uniswap router test
 
-    let {
-      controller: ctrl,
-      avatar: av,
-      gd,
-      identity,
-      daoCreator,
-      nameService: ns,
-      setDAOAddress: sda,
-      setSchemes,
-      marketMaker: mm,
-      daiAddress,
-      cdaiAddress,
-      reserve,
-      setReserveToken,
-      COMP
-    } = await createDAO();
-
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
     comp = COMP;
@@ -118,7 +120,7 @@ describe("GoodReserve - buy/sell with any token through uniswap", () => {
     });
     goodReserve = reserve;
 
-    setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
+    await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
     const exchangeHelperFactory = await ethers.getContractFactory(
       "ExchangeHelper"
     );
@@ -435,7 +437,7 @@ describe("GoodReserve - buy/sell with any token through uniswap", () => {
         0,
         NULL_ADDRESS
       )
-    ).to.be.revertedWith("ERC20: transfer amount exceeds allowance");
+    ).to.be.revertedWith("ERC20: insufficient allowance");
   });
 
   it("shouldn't be able to sell gd to tokenA through UNISWAP without approve", async () => {

package/test/staking/CompoundStakingFactory.test.ts

@@ -1,5 +1,5 @@
 import { default as hre, ethers, upgrades } from "hardhat";
-import { deployMockContract, MockContract } from "ethereum-waffle";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import {
   CERC20,
@@ -27,7 +27,7 @@ describe("CompoundStakingFactory", () => {
 
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
-    dao = await createDAO();
+    dao = await loadFixture(createDAO);
 
     const compUsdOracleFactory = await ethers.getContractFactory(
       "CompUSDMockOracle"
@@ -128,13 +128,16 @@ describe("CompoundStakingFactory", () => {
 
     const INITIAL_COLLECT_INTEREST_GAS_COST = 250000;
     const INITIAL_COLLECT_COMP_GAS_COST = 150000;
-    const gasCostForInterestTransfer = await goodCompoundStakingV2.getGasCostForInterestTransfer();
-    expect(gasCostForInterestTransfer).to.equal(INITIAL_COLLECT_INTEREST_GAS_COST);
+    const gasCostForInterestTransfer =
+      await goodCompoundStakingV2.getGasCostForInterestTransfer();
+    expect(gasCostForInterestTransfer).to.equal(
+      INITIAL_COLLECT_INTEREST_GAS_COST
+    );
 
     const settings = await goodCompoundStakingV2.getSettings();
     const collectInteresetGasCost = settings[0];
     const compCollectGasCost = settings[1];
     expect(collectInteresetGasCost).to.equal(INITIAL_COLLECT_INTEREST_GAS_COST);
     expect(compCollectGasCost).to.equal(INITIAL_COLLECT_COMP_GAS_COST);
-    });
+  });
 });

package/test/staking/DifferentStakingTokens.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 import {
@@ -57,14 +58,14 @@ describe("Different decimals staking token", () => {
       genericCall: gc,
       setDAOAddress,
       COMP
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     comp = COMP;
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
     uniswap = await deployUniswap(comp, dai);
     uniswapRouter = uniswap.router;
-    setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
+    await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
     avatar = av;
     controller = ctrl;
     genericCall = gc;

package/test/staking/DonationsStaking.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, constants, Contract } from "ethers";
 import { expect } from "chai";
 import {
@@ -77,7 +78,7 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
       reserve,
       setReserveToken,
       genericCall: gc
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     comp = await daiFactory.deploy();
     genericCall = gc;
@@ -235,7 +236,7 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
       "no stakingToken to stake"
     );
   });
-  
+
   it("it should stake donations with ETH according to 0.3% of pool", async () => {
     let stakeAmount = ethers.utils.parseEther("20");
     const pairContract = await ethers.getContractAt(
@@ -315,15 +316,15 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
 
     expect(totalStakedAfterEnd).to.be.equal(0);
   });
-  
+
   it("should not allow to stake donations when not active", async () => {
     let isActive = await donationsStaking.active();
     expect(isActive).to.be.equal(true);
     let stakeAmount = ethers.utils.parseEther("10");
     await dai["mint(address,uint256)"](donationsStaking.address, stakeAmount);
-    
+
     expect(donationsStaking.stakeDonations()).to.not.be.reverted;
-    
+
     let encodedData = donationsStaking.interface.encodeFunctionData(
       "setActive",
       [false]
@@ -335,10 +336,9 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
     await dai["mint(address,uint256)"](donationsStaking.address, stakeAmount);
     await expect(donationsStaking.stakeDonations()).to.be.reverted;
     // revent to original state
-    encodedData = donationsStaking.interface.encodeFunctionData(
-      "setActive",
-      [true]
-    );
+    encodedData = donationsStaking.interface.encodeFunctionData("setActive", [
+      true
+    ]);
     await genericCall(donationsStaking.address, encodedData);
   });
 
@@ -354,18 +354,18 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
 
     // Invalid scenarios checks
     const invalidPaths = [
-      [NULL_ADDRESS],             // less than minimum 2 length
+      [NULL_ADDRESS], // less than minimum 2 length
       [bat.address, dai.address], // first is not ETH null address
       [NULL_ADDRESS, bat.address] // last is not the staking token
     ];
 
     for (const invalidPath of invalidPaths) {
       encodedData = donationsStaking.interface.encodeFunctionData(
-      "setSwapPaths",
-      [invalidPath]
+        "setSwapPaths",
+        [invalidPath]
       );
       await genericCall(donationsStaking.address, encodedData);
-      expect(await isEthToStakingTokenPathEqualTo(invalidPath)).to.be.false;  
+      expect(await isEthToStakingTokenPathEqualTo(invalidPath)).to.be.false;
     }
 
     encodedData = donationsStaking.interface.encodeFunctionData(
@@ -374,23 +374,27 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
     );
     await genericCall(donationsStaking.address, encodedData);
   });
-  
+
   async function isEthToStakingTokenPathEqualTo(path) {
     for (let index = 0; index < path.length; index++) {
       let expectedValue = path[index];
-      let valueAtIndex = await donationsStaking.ethToStakingTokenSwapPath(index).catch(e=>e);
+      let valueAtIndex = await donationsStaking
+        .ethToStakingTokenSwapPath(index)
+        .catch(e => e);
       if (expectedValue != valueAtIndex) {
         return false;
       }
     }
 
-    const outOfArray = await donationsStaking.ethToStakingTokenSwapPath(path.length).catch(e=>e);
+    const outOfArray = await donationsStaking
+      .ethToStakingTokenSwapPath(path.length)
+      .catch(e => e);
     if (!outOfArray.message) {
       return false;
     }
 
     return true;
-  }  
+  }
 
   it("it should set stakingContract when avatar call it ", async () => {
     let stakeAmount = ethers.utils.parseEther("6000"); // Max swap amount is around 5964 with current liquidity level so we should set it to higher number in order to test functionality
@@ -473,21 +477,26 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
       avatarDaiBalanceBeforeSet.add(stakingAmountBeforeSet.sub(safeAmount))
     ); // It should send leftover stakingToken to avatar after swap to ETH in safeAmount
     expect(stakingAmountBeforeSet).to.be.gt(safeAmount); // maxSafeAmount must be smaller than actualstaking amount so we can verify that we hit the limit for transaction amount at once
-  }); 
-  
+  });
+
   it("should set max liquidity percentage swap when avatar", async () => {
-    const originalPercentage = await donationsStaking.maxLiquidityPercentageSwap();
+    const originalPercentage =
+      await donationsStaking.maxLiquidityPercentageSwap();
     //fail when not avatar
     const percentageToSet = 21;
-    expect(donationsStaking.connect(staker)["setMaxLiquidityPercentageSwap(uint24)"](percentageToSet)).
-      to.be.revertedWith("only avatar can call this method");
+    expect(
+      donationsStaking
+        .connect(staker)
+        ["setMaxLiquidityPercentageSwap(uint24)"](percentageToSet)
+    ).to.be.revertedWith("only avatar can call this method");
     //succeed when avatar
     let encodedData = donationsStaking.interface.encodeFunctionData(
       "setMaxLiquidityPercentageSwap",
       [percentageToSet]
     );
     await genericCall(donationsStaking.address, encodedData);
-    const actualPercentage = await donationsStaking.maxLiquidityPercentageSwap();
+    const actualPercentage =
+      await donationsStaking.maxLiquidityPercentageSwap();
     expect(actualPercentage).to.be.equal(percentageToSet);
     //revent to original state
     encodedData = donationsStaking.interface.encodeFunctionData(
@@ -500,4 +509,4 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
     const version = await donationsStaking.getVersion();
     expect(version).to.be.equal("2.0.0");
   });
-});
+});

package/test/staking/FuseStaking.test.ts

@@ -1,8 +1,8 @@
-import { ethers, network as networkConfig } from "hardhat";
+import hre, { ethers, network as networkConfig, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { FuseStakingV3 } from "../../types";
 import { expect } from "chai";
-import { deployMockContract, MockContract } from "ethereum-waffle";
-import hre from "hardhat";
+import { MockContract } from "ethereum-waffle";
 import { abi as ubiabi } from "../../artifacts/contracts/ubi/UBIScheme.sol/UBIScheme.json";
 import { BigNumber } from "ethers";
 export const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
@@ -23,14 +23,14 @@ describe("FuseStakingV3", () => {
     let u = await hre.artifacts.readArtifact("Uniswap");
     let uf = await hre.artifacts.readArtifact("UniswapFactory");
     let up = await hre.artifacts.readArtifact("UniswapPair");
-    uniswap = await deployMockContract(signers[0], u.abi);
-    uniswapFactory = await deployMockContract(signers[0], uf.abi);
-    uniswapPair = await deployMockContract(signers[0], up.abi);
+    uniswap = await waffle.deployMockContract(signers[0], u.abi);
+    uniswapFactory = await waffle.deployMockContract(signers[0], uf.abi);
+    uniswapPair = await waffle.deployMockContract(signers[0], up.abi);
 
-    gdusdcPair = await deployMockContract(signers[0], up.abi);
-    fusefusdPair = await deployMockContract(signers[0], up.abi);
+    gdusdcPair = await waffle.deployMockContract(signers[0], up.abi);
+    fusefusdPair = await waffle.deployMockContract(signers[0], up.abi);
 
-    ubiMock = await deployMockContract(signers[0], ubiabi);
+    ubiMock = await waffle.deployMockContract(signers[0], ubiabi);
     await uniswap.mock.factory.returns(uniswapFactory.address);
     await uniswap.mock.WETH.returns(signers[3].address);
     await uniswapFactory.mock.getPair.returns(uniswapPair.address);

package/test/staking/GoodAaveStakingFactory.test.ts

@@ -1,7 +1,12 @@
 import { default as hre, ethers, upgrades } from "hardhat";
-import { deployMockContract, MockContract } from "ethereum-waffle";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-import { CERC20, GoodAaveStaking, GoodAaveStakingV2, AaveStakingFactory } from "../../types";
+import {
+  CERC20,
+  GoodAaveStaking,
+  GoodAaveStakingV2,
+  AaveStakingFactory
+} from "../../types";
 import { createDAO, deployUniswap } from "../helpers";
 import { Contract } from "ethers";
 
@@ -25,7 +30,7 @@ describe("AaveStakingFactory", () => {
 
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
-    dao = await createDAO();
+    dao = await loadFixture(createDAO);
     const usdcFactory = await ethers.getContractFactory("USDCMock");
     const lendingPoolFactory = await ethers.getContractFactory(
       "LendingPoolMock"
@@ -128,33 +133,33 @@ describe("AaveStakingFactory", () => {
       "GoodAaveStakingV2",
       await stakingFactory.impl()
     )) as GoodAaveStakingV2;
-    await expect(goodAaveStakingV2.init(
-      usdc.address,
-      lendingPool.address,
-      dao.nameService.address,
-      "USDC",
-      "USDC",
-      5760,
-      stakingFactory.address,
-      incentiveController.address,
-      aaveUsdOracle.address,
-      [cdai, dai]           // violates tokenToDaiSwapPath[0] == _token (cdai != usdc)
-    )).to.be.revertedWith(
-      "invalid _tokenToDaiSwapPath"
-    );
-    await expect(goodAaveStakingV2.init(
-      usdc.address,
-      lendingPool.address,
-      dao.nameService.address,
-      "USDC",
-      "USDC",
-      5760,
-      stakingFactory.address,
-      incentiveController.address,
-      aaveUsdOracle.address,
-      [usdc.address, cdai]  // violates _tokenToDaiSwapPath[] path leading to dai
-    )).to.be.revertedWith(
-      "invalid _tokenToDaiSwapPath"
-    );
+    await expect(
+      goodAaveStakingV2.init(
+        usdc.address,
+        lendingPool.address,
+        dao.nameService.address,
+        "USDC",
+        "USDC",
+        5760,
+        stakingFactory.address,
+        incentiveController.address,
+        aaveUsdOracle.address,
+        [cdai, dai] // violates tokenToDaiSwapPath[0] == _token (cdai != usdc)
+      )
+    ).to.be.revertedWith("invalid _tokenToDaiSwapPath");
+    await expect(
+      goodAaveStakingV2.init(
+        usdc.address,
+        lendingPool.address,
+        dao.nameService.address,
+        "USDC",
+        "USDC",
+        5760,
+        stakingFactory.address,
+        incentiveController.address,
+        aaveUsdOracle.address,
+        [usdc.address, cdai] // violates _tokenToDaiSwapPath[] path leading to dai
+      )
+    ).to.be.revertedWith("invalid _tokenToDaiSwapPath");
   });
 });

package/test/staking/SimpleDAIStaking.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { Contract } from "ethers";
 import { expect } from "chai";
 import { GoodMarketMaker, GoodReserveCDai } from "../../types";
@@ -57,8 +58,8 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
       cdaiAddress,
       reserve,
       setReserveToken,
-      runAsAvatarOnly: raao,
-    } = await createDAO();
+      runAsAvatarOnly: raao
+    } = await loadFixture(createDAO);
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
     avatar = av;
@@ -94,7 +95,7 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
     daiUsdOracle = await tokenUsdOracleFactory.deploy();
     const daiFactory = await ethers.getContractFactory("DAIMock");
 
-    setDAOAddress("UNISWAP_ROUTER", signers[0].address); // need this address for initialize simplestaking
+    await setDAOAddress("UNISWAP_ROUTER", signers[0].address); // need this address for initialize simplestaking
     const compUsdOracleFactory = await ethers.getContractFactory(
       "CompUSDMockOracle"
     );
@@ -1103,9 +1104,7 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
       .connect(staker)
       .stake(stakingAmount, 100, true)
       .catch(e => e);
-    expect(transaction.message).to.have.string(
-      "ERC20: transfer amount exceeds allowance"
-    );
+    expect(transaction.message).to.have.string("ERC20: insufficient allowance");
   });
   it("it should be able stake and withdraw their stake in iToken", async () => {
     const stakingAmount = ethers.utils.parseUnits("100", 8);
@@ -1264,17 +1263,12 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
   it("should not be able to withdraw stake when the withdrawn amount is higher than the staked amount", async () => {
     const stakeAmount = ethers.utils.parseEther("100");
     const higherThanStakeAmount = ethers.utils.parseEther("101");
-    await cDAI["mint(address,uint256)"](
-      staker.address,
-      stakeAmount
-    );
+    await cDAI["mint(address,uint256)"](staker.address, stakeAmount);
     await cDAI
       .connect(staker)
       .approve(goodCompoundStaking.address, higherThanStakeAmount);
 
-    await goodCompoundStaking
-      .connect(staker)
-      .stake(stakeAmount, "100", true);
+    await goodCompoundStaking.connect(staker).stake(stakeAmount, "100", true);
 
     const tx = await goodCompoundStaking
       .connect(staker)
@@ -1283,9 +1277,7 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
 
     expect(tx.message).to.be.not.empty;
     // revent to original state
-    await goodCompoundStaking
-      .connect(staker)
-      .withdrawStake(stakeAmount, true);
+    await goodCompoundStaking.connect(staker).withdrawStake(stakeAmount, true);
   });
 
   it("should pause the contract", async () => {
@@ -1456,14 +1448,16 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
 
   it("should set max liquidity percentage swap when avatar", async () => {
     goodCompoundStaking = await deployStaking();
-    const percentageBeforeSet = await goodCompoundStaking.maxLiquidityPercentageSwap();
+    const percentageBeforeSet =
+      await goodCompoundStaking.maxLiquidityPercentageSwap();
     const percentageToSet = 21;
     await runAsAvatarOnly(
       goodCompoundStaking,
       "setMaxLiquidityPercentageSwap(uint24)",
       percentageToSet
-    )
-    const percentageAfterSet = await goodCompoundStaking.maxLiquidityPercentageSwap();
+    );
+    const percentageAfterSet =
+      await goodCompoundStaking.maxLiquidityPercentageSwap();
     expect(percentageAfterSet).to.be.equal(percentageToSet);
     expect(percentageAfterSet).to.not.equal(percentageBeforeSet);
   });

package/test/staking/StakingRewards.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 import { GoodMarketMaker } from "../../types";
@@ -51,19 +52,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
-    const cdaiFactory = await ethers.getContractFactory("cDAIMock");
-    const cBatFactory = await ethers.getContractFactory("cBATMock");
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    goodCompoundStakingFactory = await getStakingFactory(
-      "GoodCompoundStakingV2"
-    );
-    goodCompoundStakingTestFactory = await getStakingFactory(
-      "GoodCompoundStakingTest"
-    );
 
-    const daiFactory = await ethers.getContractFactory("DAIMock");
     let {
       controller: ctrl,
       avatar: av,
@@ -79,7 +68,21 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       setReserveToken,
       genericCall: gc,
       COMP
-    } = await createDAO();
+    } = await loadFixture(createDAO);
+
+    const cdaiFactory = await ethers.getContractFactory("cDAIMock");
+    const cBatFactory = await ethers.getContractFactory("cBATMock");
+    const goodFundManagerFactory = await ethers.getContractFactory(
+      "GoodFundManager"
+    );
+    goodCompoundStakingFactory = await getStakingFactory(
+      "GoodCompoundStakingV2"
+    );
+    goodCompoundStakingTestFactory = await getStakingFactory(
+      "GoodCompoundStakingTest"
+    );
+
+    const daiFactory = await ethers.getContractFactory("DAIMock");
 
     genericCall = gc;
     dai = await ethers.getContractAt("DAIMock", daiAddress);
@@ -129,7 +132,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const tokenUsdOracleFactory = await ethers.getContractFactory(
       "BatUSDMockOracle"
     );
-    setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
+    await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
 
     daiUsdOracle = await tokenUsdOracleFactory.deploy();
     const compUsdOracleFactory = await ethers.getContractFactory(
@@ -194,8 +197,8 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       JSON.stringify(IUniswapV2Pair.abi),
       staker
     ).connect(founder);
-    setDAOAddress("CDAI", cDAI.address);
-    setDAOAddress("DAI", dai.address);
+    await setDAOAddress("CDAI", cDAI.address);
+    await setDAOAddress("DAI", dai.address);
 
     batUsdOracle = await tokenUsdOracleFactory.deploy();
 

package/test/staking/StakingRewardsFixedAPY.test.ts

@@ -1,5 +1,6 @@
 import { expect } from "chai";
 import { ethers, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { createDAO, advanceBlocks } from "../helpers";
 import { StakingMockFixedAPY } from "../../types";
 import { default as StakingABI } from "../../artifacts/contracts/mocks/StakingMockFixedAPY.sol/StakingMockFixedAPY.json";
@@ -61,7 +62,7 @@ describe("StakingRewardsFixedAPY - generic staking for fixed APY rewards contrac
       gd,
       nameService: ns,
       setDAOAddress
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     setNSAddress = setDAOAddress;
     nameService = ns;

package/test/staking/SwapHelper.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 
@@ -38,6 +39,24 @@ describe("SwapHelper - Helper library for swap on the Uniswap", () => {
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
+
+    let {
+      controller: ctrl,
+      avatar: av,
+      gd,
+      identity,
+      nameService: ns,
+      setDAOAddress: sda,
+      setSchemes,
+      marketMaker: mm,
+      daiAddress,
+      cdaiAddress,
+      reserve,
+      setReserveToken,
+      genericCall: gc,
+      COMP
+    } = await loadFixture(createDAO);
+
     const cdaiFactory = await ethers.getContractFactory("cDAIMock");
     const cBatFactory = await ethers.getContractFactory("cDecimalsMock");
     const goodFundManagerFactory = await ethers.getContractFactory(
@@ -54,22 +73,6 @@ describe("SwapHelper - Helper library for swap on the Uniswap", () => {
     );
     swapHelperTest = await swapHelperTestFactory.deploy();
     const daiFactory = await ethers.getContractFactory("DAIMock");
-    let {
-      controller: ctrl,
-      avatar: av,
-      gd,
-      identity,
-      nameService: ns,
-      setDAOAddress: sda,
-      setSchemes,
-      marketMaker: mm,
-      daiAddress,
-      cdaiAddress,
-      reserve,
-      setReserveToken,
-      genericCall: gc,
-      COMP
-    } = await createDAO();
 
     genericCall = gc;
     dai = await ethers.getContractAt("DAIMock", daiAddress);
@@ -109,7 +112,7 @@ describe("SwapHelper - Helper library for swap on the Uniswap", () => {
     const tokenUsdOracleFactory = await ethers.getContractFactory(
       "BatUSDMockOracle"
     );
-    setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
+    await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
 
     const compUsdOracleFactory = await ethers.getContractFactory(
       "CompUSDMockOracle"