@gooddollar/goodprotocol 2.0.5-beta.5 → 2.0.5-beta.7

package/scripts/proposals/gip-14_1.ts

@@ -0,0 +1,255 @@
+/**
+ * increase rate of UBI distribution on Celo
+ * also includes old foundation funds transfers from firstclaimpool and avatar towards initial topping of the UBI pool for the launch campaign
+ */
+
+import { ethers, network } from "hardhat";
+import { defaultsDeep } from "lodash";
+import prompt from "prompt";
+import { reset } from "@nomicfoundation/hardhat-network-helpers";
+
+import { executeViaGuardian, executeViaSafe, verifyProductionSigner } from "../multichain-deploy/helpers";
+
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+
+const { name: networkName } = network;
+
+export const step1 = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName.split("-")[0];
+  const isForkSimulation = networkName === "localhost";
+  if (isForkSimulation) networkEnv = "production";
+  const fuseNetwork = networkEnv;
+
+  if (networkEnv === "fuse") networkEnv = "development";
+  const celoNetwork = networkEnv + "-celo";
+  const mainnetNetwork = `${networkName === "localhost" ? "production" : networkName}-mainnet`; //simulate production on localhost requires running hardhat node in fork mode
+
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+  if (isForkSimulation)
+    // fund safe with eth so we can simulate TXs
+    await root.sendTransaction({ to: dao[mainnetNetwork].GuardiansSafe, value: ethers.constants.WeiPerEther });
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString()),
+    mainnetNetwork,
+    fuseNetwork,
+    celoNetwork
+  });
+
+  const proposalContracts = [
+    dao[mainnetNetwork].GoodReserveCDai, // update the nonubi bps to 55%. 10% community fund + 45% celo ubi
+    dao[mainnetNetwork].DistributionHelper, //set community fund to 0.1818 so it gets 10% from 55%
+    dao[mainnetNetwork].DistributionHelper //set celo ubi to 0.8182 so it gets 45% from 55%
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setDistributionHelper(address,uint32)",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address", "uint32"], [dao[mainnetNetwork].DistributionHelper, 5500]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [8182, 42220, dao[celoNetwork].UBIScheme, 1]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [1818, 122, dao[fuseNetwork].CommunitySafe, 0] //community safe on fuse
+    )
+  ];
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "mainnet"
+    );
+  } else {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      isForkSimulation ? await ethers.getImpersonatedSigner(dao[mainnetNetwork].GuardiansSafe) : root,
+      mainnetNetwork
+    );
+  }
+
+  if (isForkSimulation) {
+    const reserve = await ethers.getContractAt("GoodReserveCDai", dao[mainnetNetwork].GoodReserveCDai);
+    //verify balance of avatar is 0
+    const events = await reserve.queryFilter(reserve.filters.DistributionHelperSet(), -10);
+    console.log({ events });
+    console.assert(events[0].args?.bps === 5500, "wrong bps");
+    const helper = await ethers.getContractAt("DistributionHelper", dao[mainnetNetwork].DistributionHelper);
+    const helperEvents = await helper.queryFilter(helper.filters.RecipientUpdated(), -10);
+    console.log(
+      "helperEvents",
+      helperEvents.map(_ => _.args)
+    );
+
+    //verify multichain bridge did burn
+    console.assert(
+      helperEvents.find(
+        _ =>
+          _.args?.recipient[0] === 1818 &&
+          _.args?.recipient[2] == dao[fuseNetwork].CommunitySafe &&
+          _.args?.recipient[1] === 122 &&
+          _.args?.recipient[3] === 0
+      ),
+      "wrong community pool bps"
+    );
+    console.assert(
+      helperEvents.find(
+        _ =>
+          _.args?.recipient[0] === 8182 &&
+          _.args?.recipient[2] == dao[celoNetwork].UBIScheme &&
+          _.args?.recipient[1] === 42220 &&
+          _.args?.recipient[3] === 1
+      ),
+      "wrong celo ubi pool bps"
+    );
+  }
+};
+
+export const step2 = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName.split("-")[0];
+  const isForkSimulation = networkName === "localhost";
+  if (isForkSimulation) networkEnv = "production";
+  const fuseNetwork = networkEnv;
+
+  if (networkEnv === "fuse") networkEnv = "development";
+  const celoNetwork = networkEnv + "-celo";
+  const mainnetNetwork = `${networkName === "localhost" ? "production" : networkName}-mainnet`; //simulate production on localhost requires running hardhat node in fork mode
+
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+  if (isForkSimulation)
+    // fund safe with eth so we can simulate TXs
+    await root.sendTransaction({ to: dao[fuseNetwork].GuardiansSafe, value: ethers.constants.WeiPerEther });
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString()),
+    mainnetNetwork,
+    fuseNetwork,
+    celoNetwork
+  });
+
+  const fuseProposalContracts = [
+    dao[fuseNetwork].FirstClaimPool, // end the pool to get locked funds
+    dao[fuseNetwork].GoodDollar, //approve multichain wrapper
+    dao[fuseNetwork].MultichainRouter //anyswapout
+  ];
+
+  const fuseProposalEthValues = fuseProposalContracts.map(_ => 0);
+
+  const fuseProposalFunctionSignatures = [
+    "end()",
+    // "transferAndCall(address,uint256,bytes)"//transferAndcall not working in simulation. using aprrove+anyswapout
+    "approve(address,uint256)",
+    "anySwapOut(address,address,uint256,uint256)"
+  ];
+
+  const gd = await ethers.getContractAt("GoodDollar", dao[fuseNetwork].GoodDollar);
+  const aBalance = await gd.balanceOf(dao[fuseNetwork].Avatar);
+  const bBalance = await gd.balanceOf(dao[fuseNetwork].FirstClaimPool);
+
+  console.log("balances to bridge:", aBalance.toString(), bBalance.toString());
+  const fuseProposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode([], []),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint256"],
+      [dao[fuseNetwork].GoodDollarMintBurnWrapper, aBalance.add(bBalance)]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "address", "uint256", "uint256"],
+      [dao[fuseNetwork].GoodDollarMintBurnWrapper, dao[celoNetwork].UBIScheme, aBalance.add(bBalance), 42220]
+    )
+
+    //transferAndCall isnt working in simualation for some reason
+    // ethers.utils.defaultAbiCoder.encode(
+    //   ["address", "uint256", "bytes"],
+    //   [
+    //     dao[fuseNetwork].GoodDollarMintBurnWrapper,
+    //     aBalance.add(bBalance),
+    //     ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [dao[celoNetwork].UBIScheme, 42220])
+    //   ] //target ubipool on celo for multichain bridge
+    // )
+  ];
+
+  const totalSupplyBefore = await gd.totalSupply();
+  if (isProduction) {
+    await executeViaSafe(
+      fuseProposalContracts,
+      fuseProposalEthValues,
+      fuseProposalFunctionSignatures,
+      fuseProposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "fuse"
+    );
+  } else {
+    await executeViaGuardian(
+      fuseProposalContracts,
+      fuseProposalEthValues,
+      fuseProposalFunctionSignatures,
+      fuseProposalFunctionInputs,
+      isForkSimulation ? await ethers.getImpersonatedSigner(dao[fuseNetwork].GuardiansSafe) : root,
+      fuseNetwork
+    );
+  }
+
+  if (isForkSimulation) {
+    //verify balance of avatar is 0
+    console.assert((await gd.balanceOf(dao[fuseNetwork].Avatar)).eq(0), await gd.balanceOf(dao[fuseNetwork].Avatar));
+    //verify multichain bridge did burn
+    console.assert((await gd.totalSupply()).lt(totalSupplyBefore), "bridge didnt burn G$s");
+  }
+};
+
+export const main = async () => {
+  prompt.start();
+  const { stepNumber } = await prompt.get(["stepNumber"]);
+
+  console.log("running step:", { stepNumber });
+  switch (stepNumber) {
+    case "1":
+      await reset("https://cloudflare-eth.com");
+      await step1();
+      break;
+
+    //to simulate run first
+    //npx hardhat node --fork https://rpc.fuse.io
+    //then run npx hardhat run scripts/proposals/gip-14_1.ts --network localhost
+    case "2":
+      await reset("https://rpc.fuse.io");
+      await step2();
+      break;
+  }
+  // await upgrade().catch(console.log);
+};
+
+main();

package/scripts/proposals/gips-14_1.md

@@ -0,0 +1,29 @@
+## Mainnet on-chain proposal
+
+- On mainnet we send 10% to community pool and 50% of the remaining 90% (ie 45%) to the Celo UBI Pool, so in total its 55% we distribute via the distribution helper.
+- 10% of the 55% is 0.1818 or 1818 in bps
+- 45% of the 55% is 0.8182 or 8182 in bps
+
+| contract                                                       | method                                                          | arguments                                                                                                        |
+| -------------------------------------------------------------- | --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| Reserve: 0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0            | setDistributionHelper(DistributionHelper \_helper, uin32 \_bps) | (DistributionHelper:"0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0",5500)                                           |
+| DistributionHelper: 0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0 | addOrUpdateRecipient(DistributionRecipient memory \_recipient)  | {bps: 8182, chainId: 42220, addr: CeloUBIScheme:'0x43d72Ff17701B2DA814620735C39C620Ce0ea4A1', transferType: 1}   |
+| DistributionHelper: 0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0 | addOrUpdateRecipient(DistributionRecipient memory \_recipient)  | {bps: 1818, chainId: 122, addr: FuseCommunitySafe:'0x5Eb5f5fE13d1D5e6440DbD5913412299Bc5B5564', transferType: 0} |
+
+## Fuse on-chain proposal
+
+- On fuse we collect funds from FirstClaimPool and then transfer these funds + older funds in Avatar (also from older FirstClaimPool/Invite contracts funded by GoodLabs) to the UBI Pool on Celo via the multichain bridge
+
+| contract                                                     | method                                                                         | arguments                                                                                                                                                       |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstClaimPool: 0x18BcdF79A724648bF34eb06701be81bD072A2384   | end()                                                                          |                                                                                                                                                                 |
+| GoodDollar: 0x495d133B938596C9984d462F007B676bDc57eCEC       | approve(address spender,uint256 amount)                                        | (GoodDollarMintBurnWrapper:"0x031b2B7C7854dd8EE9C4A644D7e54aD17F56e3cB",128069283 + 463420500)                                                                  |
+| MultichainRouter: 0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0 | function anySwapOut(address token,address to,uint256 amount,uint256 toChainID) | (GoodDollarMintBurnWrapper:"0x031b2B7C7854dd8EE9C4A644D7e54aD17F56e3cB",CeloUBIScheme:"0x43d72Ff17701B2DA814620735C39C620Ce0ea4A1",128069283 + 463420500,42220) |
+
+## To Test/Simulate on a forked chain
+
+- `npx hardhat node --fork https://rpc.fuse.io &`
+- `npx hardhat run scripts/proposals/gip-14_1.ts --network localhost`
+- Choose step:
+  1: run mainnet proposal
+  2: run fuse proposal

package/test/faucet/Faucet.test.ts

@@ -1,158 +1,194 @@
 import hre, { ethers, upgrades } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-import { Faucet, IGoodDollar, IIdentity } from "../../types";
+import { Faucet, FuseFaucetV2, IGoodDollar, IIdentity } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
 import { createDAO } from "../helpers";
 
 const BN = ethers.BigNumber;
-
-describe("Faucet", () => {
-  let faucet: Faucet, founder: SignerWithAddress;
-  let user1 = ethers.Wallet.createRandom().connect(ethers.provider);
-  let user2 = ethers.Wallet.createRandom().connect(ethers.provider);
-  let signers;
-
-  let avatar, gd: IGoodDollar, Controller, id: IIdentity;
-
-  before(async () => {
-    [founder, ...signers] = await ethers.getSigners();
-
-    const FuseFaucetF = await ethers.getContractFactory("Faucet");
-
-    let { daoCreator, controller, avatar: av, gd: gooddollar, identity, nameService } = await loadFixture(createDAO);
-
-    Controller = controller;
-    avatar = av;
-
-    // await daoCreator.setSchemes(
-    //   avatar,
-    //   [identity],
-    //   [ethers.constants.HashZero],
-    //   ["0x0000001F"],
-    //   ""
-    // );
-    //NameService _ns,
-    // uint64 _gasPrice,
-    // address relayer,
-    // address owner
-    faucet = (await upgrades.deployProxy(
-      FuseFaucetF,
-      [nameService.address, 1e10, signers[0].address, founder.address],
-      {
-        kind: "uups"
-      }
-    )) as Faucet;
-
-    gd = (await ethers.getContractAt("IGoodDollar", gooddollar, founder)) as IGoodDollar;
-    id = (await ethers.getContractAt("IIdentity", identity, founder)) as IIdentity;
-
-    await founder.sendTransaction({
-      value: ethers.utils.parseEther("1"),
-      to: faucet.address
+["FuseFaucetV2", "Faucet"].forEach(factory => {
+  describe(factory, () => {
+    let faucet: FuseFaucetV2 | Faucet, founder: SignerWithAddress, fuseFaucet: FuseFaucetV2, faucets;
+    let user1 = ethers.Wallet.createRandom().connect(ethers.provider);
+    let user2 = ethers.Wallet.createRandom().connect(ethers.provider);
+    let signers;
+
+    let avatar, gd: IGoodDollar, Controller, id: IIdentity;
+
+    const cleanFixture = async () => {};
+    before(async () => {
+      [founder, ...signers] = await ethers.getSigners();
+
+      const FuseFaucetF = await ethers.getContractFactory(factory);
+
+      let { daoCreator, controller, avatar: av, gd: gooddollar, identity, nameService } = await loadFixture(createDAO);
+
+      Controller = controller;
+      avatar = av;
+
+      // await daoCreator.setSchemes(
+      //   avatar,
+      //   [identity],
+      //   [ethers.constants.HashZero],
+      //   ["0x0000001F"],
+      //   ""
+      // );
+
+      // faucet = (await upgrades.deployProxy(
+      //   FuseFaucetF,
+      //   [nameService.address, 1e10, signers[0].address, founder.address],
+      //   {
+      //     kind: "uups"
+      //   }
+      // )) as Faucet;
+
+      faucet = (await upgrades.deployProxy(
+        await ethers.getContractFactory("FuseFaucetV2"),
+        [nameService.address, 1e10, signers[0].address, 1000000],
+        {
+          kind: "transparent"
+        }
+      )) as FuseFaucetV2;
+
+      gd = (await ethers.getContractAt("IGoodDollar", gooddollar, founder)) as IGoodDollar;
+      id = (await ethers.getContractAt("IIdentity", identity, founder)) as IIdentity;
+
+      await founder.sendTransaction({
+        value: ethers.utils.parseEther("1"),
+        to: faucet.address
+      });
+      faucets = [fuseFaucet, faucet];
+      await loadFixture(cleanFixture);
     });
-  });
 
-  it("should have balance", async () => {
-    const balance = await ethers.provider.getBalance(faucet.address);
-    expect(balance).to.equal(ethers.utils.parseEther("1"));
-  });
-
-  it("should not unauthorized to top new user", async () => {
-    expect(await faucet.canTop(user1.address)).to.true;
-    await expect(faucet.topWallet(user1.address)).revertedWith("not authorized");
-  });
+    it("should have balance", async () => {
+      const balance = await ethers.provider.getBalance(faucet.address);
+      expect(balance).to.equal(ethers.utils.parseEther("1"));
+    });
 
-  it("should let new user top once", async () => {
-    expect(await faucet.canTop(user1.address)).to.true;
-    const tx = await (await faucet.connect(signers[0]).topWallet(user1.address)).wait();
-    const balance = await ethers.provider.getBalance(user1.address);
-    expect(balance).to.equal(await faucet.getToppingAmount());
-  });
+    it("should not unauthorized to top new user", async () => {
+      expect(await faucet.canTop(user1.address)).to.true;
+      await expect(faucet.topWallet(user1.address)).revertedWith("not authorized");
+    });
 
-  it("should not let new user top more than once", async () => {
-    await user1.sendTransaction({
-      to: ethers.constants.AddressZero,
-      value: ethers.utils.parseUnits("400000", "gwei")
+    it("should let new user top once", async () => {
+      expect(await faucet.canTop(user1.address)).to.true;
+      const tx = await (await faucet.connect(signers[0]).topWallet(user1.address)).wait();
+      const balance = await ethers.provider.getBalance(user1.address);
+      expect(balance).to.equal(await faucet.getToppingAmount());
     });
-    expect(await faucet.canTop(user1.address)).to.false;
-    await expect(faucet.connect(signers[0]).topWallet(user1.address)).to.revertedWith(
-      "User not whitelisted or not first time"
-    );
-  });
 
-  it("should not refund gas when reverted", async () => {
-    const balance = await ethers.provider.getBalance(founder.address);
-    const faucetBalance = await ethers.provider.getBalance(faucet.address);
-    expect(await faucet.canTop(user1.address)).to.false;
-    await expect(faucet.topWallet(user1.address)).to.revertedWith("User not whitelisted or not first time");
-    const balanceAfter = await ethers.provider.getBalance(founder.address);
-    const faucetBalanceAfter = await ethers.provider.getBalance(faucet.address);
-    expect(faucetBalanceAfter).to.eq(faucetBalance);
-    expect(balanceAfter).to.lt(balance);
-  });
+    it("should not let new user top more than once", async () => {
+      await user1.sendTransaction({
+        to: ethers.constants.AddressZero,
+        value: ethers.utils.parseUnits("400000", "gwei")
+      });
+      expect(await faucet.canTop(user1.address)).to.false;
+      await expect(faucet.connect(signers[0]).topWallet(user1.address)).to.revertedWith(
+        "User not whitelisted or not first time"
+      );
+    });
 
-  it("should let user top again once identified", async () => {
-    await id.addWhitelistedWithDID(user1.address, "did:1");
-    expect(await faucet.canTop(user1.address)).to.true;
-    const tx = await (await faucet.topWallet(user1.address)).wait();
-    console.log(tx.gasUsed.toString());
-    const balance = await ethers.provider.getBalance(user1.address);
-    expect(balance).to.equal(await faucet.getToppingAmount());
-  });
+    it("should not refund gas when reverted", async () => {
+      const balance = await ethers.provider.getBalance(founder.address);
+      const faucetBalance = await ethers.provider.getBalance(faucet.address);
+      expect(await faucet.canTop(user1.address)).to.false;
+      await expect(faucet.topWallet(user1.address)).to.revertedWith("User not whitelisted or not first time");
+      const balanceAfter = await ethers.provider.getBalance(founder.address);
+      const faucetBalanceAfter = await ethers.provider.getBalance(faucet.address);
+      expect(faucetBalanceAfter).to.eq(faucetBalance);
+      expect(balanceAfter).to.lt(balance);
+    });
 
-  it("should not let identified user top over daily limit", async () => {
-    await user1.sendTransaction({
-      to: ethers.constants.AddressZero,
-      value: ethers.utils.parseUnits("400000", "gwei")
+    it("should let user top again once identified", async () => {
+      await user1.sendTransaction({
+        to: ethers.constants.AddressZero,
+        value: (await ethers.provider.getBalance(user1.address)).sub(ethers.utils.parseUnits("100000", "gwei"))
+      });
+      await id.addWhitelistedWithDID(user1.address, "did:1");
+      expect(await faucet.canTop(user1.address)).to.true;
+      const tx = await (await faucet.topWallet(user1.address)).wait();
+      console.log(tx.gasUsed.toString());
+      const balance = await ethers.provider.getBalance(user1.address);
+      expect(balance).to.equal(await faucet.getToppingAmount());
     });
-    const tx = await (await faucet.topWallet(user1.address)).wait();
-    await user1.sendTransaction({
-      to: ethers.constants.AddressZero,
-      value: ethers.utils.parseUnits("400000", "gwei")
+
+    it("should not let identified user top over daily limit", async () => {
+      await user1.sendTransaction({
+        to: ethers.constants.AddressZero,
+        value: (await ethers.provider.getBalance(user1.address)).sub(ethers.utils.parseUnits("100000", "gwei"))
+      });
+      const tx = await (await faucet.topWallet(user1.address)).wait();
+      await user1.sendTransaction({
+        to: ethers.constants.AddressZero,
+        value: ethers.utils.parseUnits("400000", "gwei")
+      });
+      expect(await faucet.canTop(user1.address)).to.false;
+      await expect(faucet.topWallet(user1.address)).to.revertedWith("max daily toppings");
     });
-    expect(await faucet.canTop(user1.address)).to.false;
-    await expect(faucet.topWallet(user1.address)).to.revertedWith("max daily toppings");
-  });
 
-  // it("should not top if wallet not half empty", async () => {
-  //   expect(await faucet.canTop(founder.address)).to.false;
-  //   await expect(faucet.topWallet(founder.address)).to.revertedWith(
-  //     "User balance above minimum"
-  //   );
-  // });
-
-  it("should not let user top over weekly limit", async () => {
-    const toppingAmount = await faucet.getToppingAmount();
-    for (let i = 0; i < 5; i++) {
-      await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
-      await (await faucet.topWallet(user1.address)).wait();
+    // it("should not top if wallet not half empty", async () => {
+    //   expect(await faucet.canTop(founder.address)).to.false;
+    //   await expect(faucet.topWallet(founder.address)).to.revertedWith(
+    //     "User balance above minimum"
+    //   );
+    // });
+
+    it("should not let user top over weekly limit", async () => {
+      const toppingAmount = await faucet.getToppingAmount();
       await user1.sendTransaction({
         to: ethers.constants.AddressZero,
         value: toppingAmount.mul(80).div(100)
       });
-    }
-    await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
+      for (let i = 0; i < 2; i++) {
+        await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
+        await (await faucet.topWallet(user1.address)).wait();
+        await user1.sendTransaction({
+          to: ethers.constants.AddressZero,
+          value: toppingAmount.mul(80).div(100)
+        });
+        console.log(toppingAmount.toString(), { i });
+      }
+      // await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
 
-    expect(await faucet.canTop(user1.address)).to.false;
-    await expect(faucet.topWallet(user1.address)).to.revertedWith(
-      "User wallet has been topped too many times this week"
-    );
+      await expect(faucet.topWallet(user1.address)).to.revertedWith(
+        "User wallet has been topped too many times this week"
+      );
+      expect(await faucet.canTop(user1.address)).to.false;
 
-    //should be able to top again after some days passed
-    await ethers.provider.send("evm_increaseTime", [60 * 60 * 24 * 3]);
-    await ethers.provider.send("evm_mine", []);
+      //should be able to top again after some days passed
+      await ethers.provider.send("evm_increaseTime", [60 * 60 * 24 * 5]);
+      await ethers.provider.send("evm_mine", []);
 
-    expect(await faucet.canTop(user1.address)).to.true;
-  });
+      expect(await faucet.canTop(user1.address)).to.true;
+    });
+
+    it("should not top below minTopping", async () => {
+      await id.addWhitelistedWithDID(user2.address, "did:2");
 
-  it("should reimburse gas costs", async () => {
-    const balance = await ethers.provider.getBalance(founder.address);
-    const tx = await (await faucet.connect(signers[0]).topWallet(user2.address, { gasPrice: 1e9 })).wait();
-    // const gasCosts = tx.gasUsed.mul(1e9);
-    // const afterRefund = gasCosts.sub(await faucet["gasRefund()"]());
-    const balanceAfter = await ethers.provider.getBalance(founder.address);
-    const diff = balance.sub(balanceAfter).toNumber();
-    expect(diff).to.lt(10000);
+      const toppingAmount = await faucet.getToppingAmount();
+      console.log(toppingAmount.toString(), "topping amount");
+      const minTopping = await faucet.minTopping();
+      const balance = await ethers.provider.getBalance(founder.address);
+      await founder.sendTransaction({ to: user2.address, value: toppingAmount.mul(100 - minTopping + 1).div(100) });
+
+      expect(await faucet.canTop(user2.address)).to.be.false;
+      await expect(faucet.topWallet(user2.address)).to.revertedWith("low toTop");
+      await user2.sendTransaction({ to: founder.address, value: toppingAmount.mul(2).div(100) });
+      expect(await faucet.canTop(user2.address)).to.be.true;
+      await expect(faucet.topWallet(user2.address)).not.reverted;
+    });
+
+    it("should reimburse gas costs", async () => {
+      const tempUser = ethers.Wallet.createRandom().connect(ethers.provider);
+
+      const balance = await ethers.provider.getBalance(founder.address);
+      const tx = await (await faucet.connect(signers[0]).topWallet(tempUser.address, { gasPrice: 1e9 })).wait();
+      // const gasCosts = tx.gasUsed.mul(1e9);
+      // const afterRefund = gasCosts.sub(await faucet["gasRefund()"]());
+      const balanceAfter = await ethers.provider.getBalance(founder.address);
+      const diff = balance.sub(balanceAfter).toNumber();
+      expect(diff).to.lt(10000);
+    });
   });
 });