@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

package/test/ubi/UBISchemeCycle.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { UBIScheme } from "../../types";
 import { createDAO, deployUBI, advanceBlocks, increaseTime } from "../helpers";
@@ -26,7 +27,7 @@ describe("UBIScheme cycle", () => {
     [root, acct, claimer1, claimer2, claimer3, ...signers] =
       await ethers.getSigners();
 
-    const deployedDAO = await createDAO();
+    const deployedDAO = await loadFixture(createDAO);
     let {
       nameService: ns,
       genericCall: gn,
@@ -125,12 +126,13 @@ describe("UBIScheme cycle", () => {
     expect(
       await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
     ).to.be.equal(10); //10 days passed total
+
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait(); //claims in new ubi cycle
-    expect(
-      await goodDollar.balanceOf(claimer1.address).then(_ => _.toNumber())
-    ).to.be.equal(
-      1000 + 58593 //58 amount of new ubicycle
-    );
+    let dailyClaimAmount = (await ubiScheme.dailyCyclePool()).div(1000); //initialy we have by default min 1000 active users
+
+    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(
+      dailyClaimAmount.add(1000)
+    ); //intial 10 from first claim pool + daily
     const cycleEvent = transaction.events.find(
       e => e.event === "UBICycleCalculated"
     );
@@ -140,7 +142,8 @@ describe("UBIScheme cycle", () => {
     expect(
       await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
     ).to.be.equal(0); //new cycle started
-    expect(cycleEvent.args.dailyUBIPool).to.be.equal(117187); //pool balance: (1000000 - 62500 given to first claimer) divided by 8 days - only first claimer got 62500 in first cycle
+    //intial balance on cycle start 1000000 - 125(one user that claimed) = 999875, divide by cycle length (8) = 124984
+    expect(cycleEvent.args.dailyUBIPool).to.be.equal(124984);
   });
 
   it("should calculate cycle early if we can increase current daily pool", async () => {
@@ -177,7 +180,7 @@ describe("UBIScheme cycle", () => {
     //increase ubi pool balance
     let encoded = goodDollar.interface.encodeFunctionData("mint", [
       ubiScheme.address,
-      1000
+      100
     ]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);

package/test/utils/AdminWallet.test.ts

@@ -1,5 +1,6 @@
 import { expect } from "chai";
 import { ethers, upgrades, network } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { createDAO } from "../helpers";
 import { Contract } from "ethers";
 import { AdminWallet } from "../../types";
@@ -39,16 +40,19 @@ describe("AdminWallet", () => {
       admin2,
       toWhitelist
     ] = signers.slice(10);
-    let { identity: id } = await createDAO();
-    identity = await ethers.getContractAt("IIdentity", id);
+    let { identity: id, nameService } = await loadFixture(createDAO);
+    identity = await ethers.getContractAt("IdentityV2", id);
 
     adminWallet = (await upgrades.deployProxy(
       await ethers.getContractFactory("AdminWallet"),
-      [[], signers[0].address, id],
+      [[], nameService.address, signers[0].address, 1e10],
       { kind: "uups" }
     )) as AdminWallet;
 
-    identity.addIdentityAdmin(adminWallet.address);
+    await identity.grantRole(
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
+      adminWallet.address
+    );
 
     toppingTimes = await adminWallet.toppingTimes();
     toppingAmount = await adminWallet.toppingAmount();
@@ -87,6 +91,12 @@ describe("AdminWallet", () => {
     });
   });
 
+  it("should have owner", async () => {
+    expect(
+      await adminWallet.hasRole(ethers.constants.HashZero, signers[0].address)
+    ).to.eq(true);
+  });
+
   it("should not top admin list when empty", async () => {
     await expect(adminWallet["topAdmins(uint256)"](0)).revertedWith(
       "Admin list is empty"
@@ -142,7 +152,10 @@ describe("AdminWallet", () => {
 
     await adminWallet
       .connect(admin2)
-      .whitelist(toWhitelist.address, "did:test" + Math.random());
+      ["whitelist(address,string)"](
+        toWhitelist.address,
+        "did:test" + Math.random()
+      );
     const newBalance = await ethers.provider.getBalance(admin2.address);
     expect(newBalance).to.be.gte(expectedTopping);
   });
@@ -154,7 +167,9 @@ describe("AdminWallet", () => {
 
   it("should allow admin to whitelist and remove whitelist", async () => {
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
-    await adminWallet.connect(admin).whitelist(whitelisted.address, "did:test");
+    await adminWallet
+      .connect(admin)
+      ["whitelist(address,string)"](whitelisted.address, "did:test");
 
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
     await adminWallet.connect(admin).removeWhitelist(whitelisted.address);
@@ -164,10 +179,14 @@ describe("AdminWallet", () => {
   it("should not allow non-admin to whitelist and remove whitelist", async () => {
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
     await expect(
-      adminWallet.connect(stranger).whitelist(whitelisted.address, "did:test")
+      adminWallet
+        .connect(stranger)
+        ["whitelist(address,string)"](whitelisted.address, "did:test")
     ).revertedWith("Caller is not admin");
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
-    await adminWallet.connect(admin).whitelist(whitelisted.address, "did:test");
+    await adminWallet
+      .connect(admin)
+      ["whitelist(address,string)"](whitelisted.address, "did:test");
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
     await expect(
       adminWallet.connect(stranger).removeWhitelist(whitelisted.address)
@@ -245,20 +264,24 @@ describe("AdminWallet", () => {
 
   it("should whitelist user", async () => {
     expect(await identity.isWhitelisted(stranger2.address)).to.false;
-    await adminWallet.connect(admin2).whitelist(stranger2.address, "did:test3");
+    await adminWallet
+      .connect(admin2)
+      ["whitelist(address,string)"](stranger2.address, "did:test3");
     expect(await identity.isWhitelisted(stranger2.address)).to.true;
   });
 
   it("should not allow whitelisting with existing did", async () => {
     await expect(
-      adminWallet.connect(admin2).whitelist(stranger.address, "did:test")
+      adminWallet
+        .connect(admin2)
+        ["whitelist(address,string)"](stranger.address, "did:test")
     ).revertedWith("DID already registered");
   });
 
   it("should not allow anyone to upgrade", async () => {
     await expect(
       adminWallet.connect(admin2).upgradeTo(adminWallet.address)
-    ).revertedWith("Ownable: caller is not the owner");
+    ).revertedWith("not owner");
   });
 
   it("should allow owner to upgrade", async () => {

package/test/utils/BuyAndBridgeHelper.test.ts

@@ -0,0 +1,249 @@
+import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { expect } from "chai";
+import {
+  GoodReserveCDai,
+  DistributionBridgeMock,
+  IGoodDollar
+} from "../../types";
+import { createDAO } from "../helpers";
+
+export const NULL_ADDRESS = ethers.constants.AddressZero;
+
+describe("BuyAndBridgeHelper ", () => {
+  let goodReserve: GoodReserveCDai;
+  let goodDollar: IGoodDollar,
+    deployedDAO,
+    genericCall,
+    avatar,
+    founder,
+    signers,
+    setDAOAddress,
+    nameService,
+    cDai;
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+
+    deployedDAO = await loadFixture(createDAO);
+
+    nameService = deployedDAO.nameService;
+    genericCall = deployedDAO.genericCall;
+    cDai = deployedDAO.cdaiAddress;
+    avatar = deployedDAO.avatar;
+    setDAOAddress = deployedDAO.setDAOAddress;
+    const gd = deployedDAO.gd;
+    const identity = deployedDAO.identity;
+
+    console.log("deployed dao", {
+      founder: founder.address,
+      gd,
+      identity,
+      avatar,
+      cDai
+    });
+
+    goodDollar = (await ethers.getContractAt("IGoodDollar", gd)) as IGoodDollar;
+
+    console.log("deployed contribution, deploying reserve...", {
+      founder: founder.address
+    });
+
+    goodReserve = deployedDAO.reserve as GoodReserveCDai;
+  });
+
+  const fixture = async () => {
+    const df = await ethers.getContractFactory("DistributionHelperTestHelper");
+    const rf = await ethers.getContractFactory("DistributionBridgeMock");
+
+    await setDAOAddress("UNISWAP_ROUTER", signers[0].address);
+
+    const exchangeHelperFactory = await ethers.getContractFactory(
+      "ExchangeHelper"
+    );
+    const bnbFactory = await ethers.getContractFactory("BuyAndBridgeHelper");
+
+    const exchangeHelper = await upgrades.deployProxy(
+      exchangeHelperFactory,
+      [nameService.address],
+      { kind: "uups" }
+    );
+
+    await setDAOAddress("EXCHANGE_HELPER", exchangeHelper.address);
+
+    const bridge = (await rf.deploy()) as DistributionBridgeMock;
+
+    await setDAOAddress("MULTICHAIN_ROUTER", bridge.address);
+    await setDAOAddress("BRIDGE_CONTRACT", bridge.address);
+    await exchangeHelper.setAddresses();
+    const bnb = await bnbFactory.deploy(exchangeHelper.address);
+
+    return { exchangeHelper: bnb, bridge };
+  };
+
+  it("should have contracts updated", async () => {
+    const { exchangeHelper, bridge } = await loadFixture(fixture);
+
+    expect(await exchangeHelper.gd()).equal(goodDollar.address);
+    expect(await exchangeHelper.fuseBridge()).equal(bridge.address);
+    expect(await exchangeHelper.multiChainBridge()).equal(bridge.address);
+    expect(await exchangeHelper.anyGoodDollar()).equal(
+      ethers.constants.AddressZero
+    );
+  });
+
+  it("should buy and bridge to Fuse", async () => {
+    const { exchangeHelper, bridge } = await loadFixture(fixture);
+    let daiAmount = ethers.utils.parseEther("100");
+    const dai = await ethers.getContractAt("DAIMock", deployedDAO.daiAddress);
+
+    // const cdaiRateStored = await cDAI.exchangeRateStored();
+    await dai["mint(uint256)"](daiAmount);
+    await dai.approve(exchangeHelper.address, daiAmount);
+
+    const gdBalanceBefore = await goodDollar.balanceOf(founder.address);
+    const daiBalanceBefore = await dai.balanceOf(founder.address);
+    const priceBefore = await goodReserve["currentPrice()"]();
+    const gdxBalanceBefore = await goodReserve.balanceOf(founder.address);
+
+    let transaction = await (
+      await exchangeHelper.buyAndBridge(
+        {
+          buyPath: [dai.address],
+          tokenAmount: daiAmount,
+          minReturn: 0,
+          minDAIAmount: 0,
+          targetAddress: NULL_ADDRESS
+        },
+        122
+      )
+    ).wait();
+    const gdBalanceAfter = await goodDollar.balanceOf(founder.address);
+    const daiBalanceAfter = await dai.balanceOf(founder.address);
+    const helperBalanceAfter = await dai.balanceOf(exchangeHelper.address);
+    const priceAfter = await goodReserve["currentPrice()"]();
+    const gdxBalanceAfter = await goodReserve.balanceOf(founder.address);
+    const bridgeBalanceAfter = await goodDollar.balanceOf(bridge.address);
+    const helperGdBalanceAfter = await goodDollar.balanceOf(
+      exchangeHelper.address
+    );
+
+    expect(helperGdBalanceAfter).eq(0); //G$s should be at the fuse bridge
+    expect(helperBalanceAfter).equal(0);
+    expect(bridgeBalanceAfter).gt(0); //G$s should be at the fuse bridge
+
+    expect(gdBalanceAfter.eq(gdBalanceBefore)).to.be.true; //should not receive any G$s
+    expect(gdxBalanceAfter.gt(gdxBalanceBefore)).to.be.true; //should receive the GDX
+    expect(daiBalanceBefore.gt(daiBalanceAfter)).to.be.true;
+    expect(priceAfter.toString()).to.be.equal(priceBefore.toString());
+
+    const events = await bridge.queryFilter(bridge.filters.OnToken());
+    expect(events[0].args.sender).to.equal(exchangeHelper.address);
+    expect(events[0].args.amount).gt(0);
+    expect(events[0].args.data).to.equal(founder.address.toLowerCase());
+  });
+
+  it("should buy and bridge to Celo", async () => {
+    const { exchangeHelper, bridge } = await loadFixture(fixture);
+    let daiAmount = ethers.utils.parseEther("100");
+    const dai = await ethers.getContractAt("DAIMock", deployedDAO.daiAddress);
+
+    // const cdaiRateStored = await cDAI.exchangeRateStored();
+    await dai["mint(uint256)"](daiAmount);
+    await dai.approve(exchangeHelper.address, daiAmount);
+
+    const gdBalanceBefore = await goodDollar.balanceOf(founder.address);
+    const daiBalanceBefore = await dai.balanceOf(founder.address);
+    const priceBefore = await goodReserve["currentPrice()"]();
+    const gdxBalanceBefore = await goodReserve.balanceOf(founder.address);
+
+    let transaction = await (
+      await exchangeHelper.buyAndBridge(
+        {
+          buyPath: [dai.address],
+          tokenAmount: daiAmount,
+          minReturn: 0,
+          minDAIAmount: 0,
+          targetAddress: NULL_ADDRESS
+        },
+        42220
+      )
+    ).wait();
+    const gdBalanceAfter = await goodDollar.balanceOf(founder.address);
+    const daiBalanceAfter = await dai.balanceOf(founder.address);
+    const helperBalanceAfter = await dai.balanceOf(exchangeHelper.address);
+
+    const priceAfter = await goodReserve["currentPrice()"]();
+    const gdxBalanceAfter = await goodReserve.balanceOf(founder.address);
+    const bridgeBalanceAfter = await goodDollar.balanceOf(bridge.address);
+    const helperGdBalanceAfter = await goodDollar.balanceOf(
+      exchangeHelper.address
+    );
+
+    expect(helperGdBalanceAfter).gt(0); //in case of the mock it doesnt call transferFrom, so bought G$s stay in helper when testing multichain
+    expect(helperBalanceAfter).equal(0);
+    expect(bridgeBalanceAfter).eq(0); //in case of multichain the G$s stay with the helper
+
+    expect(gdBalanceAfter.eq(gdBalanceBefore)).to.be.true; //should not receive any G$s
+    expect(gdxBalanceAfter.gt(gdxBalanceBefore)).to.be.true; //should receive the GDX
+    expect(daiBalanceBefore.gt(daiBalanceAfter)).to.be.true;
+    expect(priceAfter.toString()).to.be.equal(priceBefore.toString());
+
+    const events = await bridge.queryFilter(bridge.filters.AnySwap());
+    expect(events[0].args.token).to.equal(await exchangeHelper.anyGoodDollar());
+    expect(events[0].args.recipient).to.equal(founder.address);
+    expect(events[0].args.amount).gt(0);
+    expect(events[0].args.chainId).to.equal(42220);
+  });
+
+  it("should fail to buy with unsupported target chain", async () => {
+    const { exchangeHelper, bridge } = await loadFixture(fixture);
+    expect(await exchangeHelper.CELO()).equal(42220);
+    expect(await exchangeHelper.FUSE()).equal(122);
+    let daiAmount = ethers.utils.parseEther("100");
+    const dai = await ethers.getContractAt("DAIMock", deployedDAO.daiAddress);
+
+    // const cdaiRateStored = await cDAI.exchangeRateStored();
+    await dai["mint(uint256)"](daiAmount);
+    await dai.approve(exchangeHelper.address, daiAmount);
+
+    await expect(
+      exchangeHelper.buyAndBridge(
+        {
+          buyPath: [dai.address],
+          tokenAmount: daiAmount,
+          minReturn: 0,
+          minDAIAmount: 0,
+          targetAddress: NULL_ADDRESS
+        },
+        12
+      )
+    ).revertedWith("chain");
+  });
+
+  it("should fail only in tests on uniswap call when buying with ether", async () => {
+    const { exchangeHelper, bridge } = await loadFixture(fixture);
+    expect(await exchangeHelper.CELO()).equal(42220);
+    expect(await exchangeHelper.FUSE()).equal(122);
+    let daiAmount = ethers.utils.parseEther("100");
+    const dai = await ethers.getContractAt("DAIMock", deployedDAO.daiAddress);
+
+    // const cdaiRateStored = await cDAI.exchangeRateStored();
+    await dai["mint(uint256)"](daiAmount);
+    await dai.approve(exchangeHelper.address, daiAmount);
+
+    await expect(
+      exchangeHelper.buyAndBridge(
+        {
+          buyPath: [NULL_ADDRESS, dai.address],
+          tokenAmount: daiAmount,
+          minReturn: 0,
+          minDAIAmount: 0,
+          targetAddress: NULL_ADDRESS
+        },
+        122,
+        { value: daiAmount }
+      )
+    ).revertedWith("Transaction reverted: function");
+  });
+});

package/test/utils/DAOUpgradeableContract.test.ts

@@ -1,5 +1,6 @@
 import { expect } from "chai";
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { createDAO } from "../helpers";
 
 describe("DAOUpgradeableContract", () => {
@@ -12,7 +13,7 @@ describe("DAOUpgradeableContract", () => {
       avatar: av,
       genericCall: gc,
       nameService: ns
-    } = await createDAO();
+    } = await createDAO(); //await loadFixture(createDAO) doesnt work here when other tests use deployMockContract (FuseStaking)
 
     avatar = av;
     genericCall = gc;
@@ -24,7 +25,7 @@ describe("DAOUpgradeableContract", () => {
     const upgradableMockFactory = await ethers.getContractFactory(
       "UpgradableMock3"
     );
-    
+
     const daoUpgradableProxy = await upgrades.deployProxy(
       upgradableMockFactory,
       [nameService.address],

package/test/utils/GoodDollarMintBurnWrapper.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,
@@ -59,7 +60,7 @@ describe("GoodDollarMintBurnWrapper", () => {
       cdaiAddress,
       genericCall: gc,
       nameService: ns
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     nameService = ns;
     genericCall = gc;
@@ -224,7 +225,7 @@ describe("GoodDollarMintBurnWrapper", () => {
   it("should have erc20 token info", async () => {
     const { wrapper } = await waffle.loadFixture(fixture);
 
-    expect(await wrapper.decimals()).to.equal(2);
+    expect(await wrapper.decimals()).to.equal(await goodDollar.decimals());
     expect(await wrapper.name()).to.equal("GoodDollar");
     expect(await wrapper.symbol()).to.equal("G$");
   });

package/test/utils/NameService.test.ts

@@ -1,5 +1,6 @@
 import { expect } from "chai";
-import { ethers, upgrades, network } from 'hardhat';
+import { ethers, upgrades, network } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { createDAO } from "../helpers";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 
@@ -8,7 +9,13 @@ export const NULL_ADDRESS = ethers.constants.AddressZero;
 export const BLOCK_INTERVAL = 1;
 
 describe("NameService - Setup and functionalities", () => {
-  let nameService, dai, avatar, controller, schemeMock, signers, genericCall, 
+  let nameService,
+    dai,
+    avatar,
+    controller,
+    schemeMock,
+    signers,
+    genericCall,
     runAsAvatarOnly;
 
   before(async () => {
@@ -29,8 +36,8 @@ describe("NameService - Setup and functionalities", () => {
       setSchemes,
       marketMaker: mm,
       genericCall: gc,
-      runAsAvatarOnly: raao,
-    } = await createDAO();
+      runAsAvatarOnly: raao
+    } = await loadFixture(createDAO);
 
     controller = ctrl;
     avatar = av;
@@ -60,7 +67,7 @@ describe("NameService - Setup and functionalities", () => {
   it("should set multiple addresses by avatar", async () => {
     await runAsAvatarOnly(
       nameService,
-      "setAddresses(bytes32[],address[])", 
+      "setAddresses(bytes32[],address[])",
       [
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes("DAI")),
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes("cDAI"))
@@ -79,32 +86,41 @@ describe("NameService - Setup and functionalities", () => {
       await ethers.getContractFactory("NameService"),
       [
         controller,
-        [
-          "CONTROLLER",
-        ].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
-        [
-          controller
-        ]
+        ["CONTROLLER"].map(_ =>
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))
+        ),
+        [controller]
       ],
       {
         kind: "uups"
       }
     );
-    const implementationBeforeUpgrade =
-      await getImplementationAddress(network.provider, nameServiceProxy.address);
-    const newNameServiceLogic = await (await ethers.getContractFactory("NameService")).deploy();
+    const implementationBeforeUpgrade = await getImplementationAddress(
+      network.provider,
+      nameServiceProxy.address
+    );
+    const newNameServiceLogic = await (
+      await ethers.getContractFactory("NameService")
+    ).deploy();
     const encodedData = nameServiceProxy.interface.encodeFunctionData(
       "upgradeTo",
       [newNameServiceLogic.address]
     );
     await (await genericCall(nameServiceProxy.address, encodedData)).wait();
-    const implementationAfterUpgrade =
-      await getImplementationAddress(network.provider, nameServiceProxy.address);
-    expect(implementationBeforeUpgrade).to.not.equal(implementationAfterUpgrade);
+    const implementationAfterUpgrade = await getImplementationAddress(
+      network.provider,
+      nameServiceProxy.address
+    );
+    expect(implementationBeforeUpgrade).to.not.equal(
+      implementationAfterUpgrade
+    );
     expect(implementationAfterUpgrade).to.equal(newNameServiceLogic.address);
 
-    const newNameServiceLogic2 = await (await ethers.getContractFactory("NameService")).deploy();
-    await expect(nameServiceProxy.upgradeTo(newNameServiceLogic2.address)).
-      to.be.revertedWith("only avatar can call this method");
-  });  
+    const newNameServiceLogic2 = await (
+      await ethers.getContractFactory("NameService")
+    ).deploy();
+    await expect(
+      nameServiceProxy.upgradeTo(newNameServiceLogic2.address)
+    ).to.be.revertedWith("only avatar can call this method");
+  });
 });

package/test/utils/ProtocolUpgrade.test.ts

@@ -1,6 +1,6 @@
 import { default as hre, ethers, upgrades, network } 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 { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
 import { deploy } from "../../scripts/test/localOldDaoDeploy";

package/test/utils/ProxyFactory.test.ts

@@ -1,7 +1,7 @@
 import hre, { ethers } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
-import { deployMockContract, MockContract } from "ethereum-waffle";
 
 import { ProxyFactory1967, ERC1967Proxy } from "../../types";
 const BN = ethers.BigNumber;
@@ -18,20 +18,22 @@ describe("proxyfactory", () => {
     factory = (await f.deploy()) as unknown as ProxyFactory1967;
   });
 
-  it("[@skip-on-coverage] [hardhat BUG] should deploy with linked library", async () => {
+  it("should deploy with linked library", async () => {
     const uf = await ethers.getContractFactory("UniswapV2SwapHelper");
     const uniswap = await uf.deploy();
     const Contract = await ethers.getContractFactory("CompoundStakingFactory", {
       libraries: { UniswapV2SwapHelper: uniswap.address }
     });
-    expect(
-      await factory.deployCode(308932532, Contract.bytecode).catch(e => e)
-    ).to.be.an("error");
-    // const tx = await (
-    //   await factory.deployCode(308932532, Contract.bytecode)
-    // ).wait();
-    // const event = tx.events.find(_ => _.event === "ContractDeployed");
-    // expect(event).not.empty;
+    // expect(
+    //   await factory.deployCode(308932532, Contract.bytecode).catch(e => e)
+    // ).to.be.an("error");
+    const tx = await (
+      await factory.deployCode(308932532, Contract.bytecode, {
+        gasLimit: 30000000 //required for hardhat, reverts without putting a specific gaslimit
+      })
+    ).wait();
+    const event = tx.events.find(_ => _.event === "ContractCreated");
+    expect(event).not.empty;
   });
 
   it("should deploy non upgradable code", async () => {