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

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 } 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 { abi as ubiabi } from "../../artifacts/contracts/ubi/UBIScheme.sol/UBIScheme.json";
 import { BigNumber } from "ethers";
 export const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";

package/test/staking/GoodAaveStakingFactory.test.ts

@@ -1,7 +1,13 @@
 import { default as hre, ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { deployMockContract, MockContract } from "ethereum-waffle";
 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 +31,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 +134,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"
     );
@@ -1264,17 +1265,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 +1279,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 +1450,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();
 
@@ -641,12 +644,13 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     await advanceBlocks(4);
 
-    const userMintedAndPending = await goodCompoundStaking.getUserMintedAndPending(staker.address);
+    const userMintedAndPending =
+      await goodCompoundStaking.getUserMintedAndPending(staker.address);
     const userMintedReward = userMintedAndPending[0].toString();
     const userPendingReward = userMintedAndPending[1].toString();
     expect(userMintedReward).to.equal("5000");
     expect(userPendingReward).to.equal("2000");
-  
+
     await goodCompoundStaking
       .connect(staker)
       .withdrawStake(stakingAmount, false);

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"

package/test/staking/UsdcAaveStaking.test.ts

@@ -1,4 +1,5 @@
 import { default as hre, ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 import { GoodMarketMaker } from "../../types";
@@ -37,17 +38,6 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
 
-    const cUsdcFactory = await ethers.getContractFactory("cUSDCMock");
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    goodAaveStakingFactory = await getStakingFactory("GoodAaveStakingV2");
-
-    const lendingPoolFactory = await ethers.getContractFactory(
-      "LendingPoolMock"
-    );
-
-    const usdcFactory = await ethers.getContractFactory("USDCMock");
     let {
       controller: ctrl,
       avatar: av,
@@ -60,7 +50,20 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
       genericCall: gc,
       COMP,
       runAsAvatarOnly: raao
-    } = await createDAO();
+    } = await loadFixture(createDAO);
+
+    const cUsdcFactory = await ethers.getContractFactory("cUSDCMock");
+    const goodFundManagerFactory = await ethers.getContractFactory(
+      "GoodFundManager"
+    );
+    goodAaveStakingFactory = await getStakingFactory("GoodAaveStakingV2");
+
+    const lendingPoolFactory = await ethers.getContractFactory(
+      "LendingPoolMock"
+    );
+
+    const usdcFactory = await ethers.getContractFactory("USDCMock");
+
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     avatar = av;
     controller = ctrl;
@@ -96,7 +99,7 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     const uniswap = await deployUniswap(comp, dai);
     uniswapRouter = uniswap.router;
     const { factory, weth } = uniswap;
-    setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
+    await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
     await factory.createPair(usdc.address, dai.address); // Create tokenA and dai pair
     const pairAddress = factory.getPair(usdc.address, dai.address);
     pair = new Contract(
@@ -139,23 +142,21 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     ).deploy();
     await setDAOAddress("AAVE", aave.address);
     deployStaking = async () => {
-      return await goodAaveStakingFactory
-        .deploy()
-        .then(async contract => {
-          await contract.init(
-            usdc.address,
-            lendingPool.address,
-            nameService.address,
-            "Good USDC",
-            "gUSDC",
-            "172800",
-            daiUsdOracle.address,
-            incentiveController.address,
-            aaveUsdOracle.address,
-            [usdc.address, dai.address]
-          );
-          return contract;
-        });
+      return await goodAaveStakingFactory.deploy().then(async contract => {
+        await contract.init(
+          usdc.address,
+          lendingPool.address,
+          nameService.address,
+          "Good USDC",
+          "gUSDC",
+          "172800",
+          daiUsdOracle.address,
+          incentiveController.address,
+          aaveUsdOracle.address,
+          [usdc.address, dai.address]
+        );
+        return contract;
+      });
     };
     goodAaveStaking = await deployStaking();
     await usdc["mint(address,uint256)"](
@@ -318,15 +319,17 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
   it("should set gas cost to interest collection parameters", async () => {
     const stakingContract = await deployStaking();
     const collectGasCostBefore = await stakingContract.collectInterestGasCost();
-    const claimStakeGasCostBefore = await stakingContract.collectInterestGasCost();
+    const claimStakeGasCostBefore =
+      await stakingContract.collectInterestGasCost();
     await runAsAvatarOnly(
       stakingContract,
       "setcollectInterestGasCostParams(uint32,uint32)",
       999,
       999
-    )
+    );
     const collectGasCostAfter = await stakingContract.collectInterestGasCost();
-    const claimStakeGasCostAfter = await stakingContract.collectInterestGasCost();
+    const claimStakeGasCostAfter =
+      await stakingContract.collectInterestGasCost();
     expect(collectGasCostAfter).to.not.equal(collectGasCostBefore);
     expect(collectGasCostAfter).to.equal(999);
     expect(claimStakeGasCostAfter).to.not.equal(claimStakeGasCostBefore);