@gooddollar/goodprotocol 1.0.30-beta.2 → 1.0.30-beta.3

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",

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);
@@ -71,10 +71,8 @@ describe("FuseStakingV3", () => {
       await ethers.getContractFactory("FuseStakingV3")
     ).deploy()) as FuseStakingV3;
 
-    await staking.initialize();
-    await staking.upgrade0();
-    await staking.upgrade1(NULL_ADDRESS, ubiMock.address, uniswap.address);
-    await staking.upgrade2();
+    await staking.initialize(uniswap.address, NULL_ADDRESS);
+    await staking.setUBIScheme(ubiMock.address);
   });
 
   it("should have owner", async () => {

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