@gooddollar/goodprotocol 2.0.5-beta.6 → 2.0.5-beta.8

package/scripts/multichain-deploy/helpers.ts

@@ -159,7 +159,8 @@ export const executeViaGuardian = async (
       results.push(tx);
     } else {
       const simulationResult = await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
-        from: await guardian.getAddress()
+        from: await guardian.getAddress(),
+        value: ethValues[i]
       });
       console.log("executing genericCall:", {
         sigHash,
@@ -211,7 +212,7 @@ export const executeViaSafe = async (
     safeSigner = safeSignerOrNetwork as any;
   }
   const chainId = await safeSigner.getChainId();
-  console.log("safeSigner:", safeSigner.address, { chainId });
+  console.log("safeSigner:", safeSigner.address, { chainId, safeAddress });
   let txServiceUrl;
   switch (chainId) {
     case 1:
@@ -251,7 +252,7 @@ export const executeViaSafe = async (
     const encoded = ethers.utils.solidityPack(["bytes4", "bytes"], [sigHash, functionInputs[i]]);
     if (contract === ctrl.address) {
       const simulationResult =
-        isSimulation === false &&
+        isSimulation === true &&
         (await ctrl.callStatic[functionSigs[i]](...functionInputs[i], {
           from: safeAddress,
           value: ethValues[i]
@@ -276,15 +277,16 @@ export const executeViaSafe = async (
       });
 
       const simulationResult =
-        isSimulation === false &&
+        isSimulation === true &&
         (await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
-          from: safeAddress
+          from: safeAddress,
+          value: ethValues[i]
         }));
       console.log("executing genericCall simulation result:", {
         sigHash,
         simulationResult
       });
-      if (isSimulation === false && simulationResult[0] === false) throw new Error("simulation failed:" + contract);
+      if (isSimulation === true && simulationResult[0] === false) throw new Error("simulation failed:" + contract);
       const genericEncode = ctrl.interface.encodeFunctionData("genericCall", [
         contract,
         encoded,

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

@@ -15,21 +15,19 @@ import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 
 const { name: networkName } = network;
+const isForkSimulation = networkName === "localhost";
 
 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
+  const mainnetNetwork = `${networkName === "localhost" ? "production" : networkName.split("-")[0]}-mainnet`; //simulate production on localhost requires running hardhat node in fork mode
 
   let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
 
@@ -133,8 +131,6 @@ 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";
@@ -208,7 +204,7 @@ export const step2 = async () => {
       fuseProposalEthValues,
       fuseProposalFunctionSignatures,
       fuseProposalFunctionInputs,
-      protocolSettings.guardiansSafe,
+      dao[fuseNetwork].GuardiansSafe,
       "fuse"
     );
   } else {
@@ -237,7 +233,7 @@ export const main = async () => {
   console.log("running step:", { stepNumber });
   switch (stepNumber) {
     case "1":
-      await reset("https://cloudflare-eth.com");
+      isForkSimulation && (await reset("https://cloudflare-eth.com"));
       await step1();
       break;
 
@@ -245,7 +241,7 @@ export const main = async () => {
     //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");
+      isForkSimulation && (await reset("https://rpc.fuse.io"));
       await step2();
       break;
   }

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

package/types/Faucet.ts

@@ -46,6 +46,7 @@ export interface FaucetInterface extends ethers.utils.Interface {
     "maxDailyToppings()": FunctionFragment;
     "maxPerWeekMultiplier()": FunctionFragment;
     "maxSwapAmount_unused()": FunctionFragment;
+    "minTopping()": FunctionFragment;
     "nameService()": FunctionFragment;
     "notFirstTime(address)": FunctionFragment;
     "onTokenTransfer(address,uint256,bytes)": FunctionFragment;
@@ -55,11 +56,11 @@ export interface FaucetInterface extends ethers.utils.Interface {
     "revokeRole(bytes32,address)": FunctionFragment;
     "setGasPrice(uint64)": FunctionFragment;
     "setGasTopping(uint256)": FunctionFragment;
+    "setMinTopping(uint8)": FunctionFragment;
     "startTime()": FunctionFragment;
     "supportsInterface(bytes4)": FunctionFragment;
     "topWallet(address)": FunctionFragment;
     "toppings(uint256,address)": FunctionFragment;
-    "upgrade()": FunctionFragment;
     "upgradeTo(address)": FunctionFragment;
     "upgradeToAndCall(address,bytes)": FunctionFragment;
     "version()": FunctionFragment;
@@ -133,6 +134,10 @@ export interface FaucetInterface extends ethers.utils.Interface {
     functionFragment: "maxSwapAmount_unused",
     values?: undefined
   ): string;
+  encodeFunctionData(
+    functionFragment: "minTopping",
+    values?: undefined
+  ): string;
   encodeFunctionData(
     functionFragment: "nameService",
     values?: undefined
@@ -169,6 +174,10 @@ export interface FaucetInterface extends ethers.utils.Interface {
     functionFragment: "setGasTopping",
     values: [BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "setMinTopping",
+    values: [BigNumberish]
+  ): string;
   encodeFunctionData(functionFragment: "startTime", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "supportsInterface",
@@ -179,7 +188,6 @@ export interface FaucetInterface extends ethers.utils.Interface {
     functionFragment: "toppings",
     values: [BigNumberish, string]
   ): string;
-  encodeFunctionData(functionFragment: "upgrade", values?: undefined): string;
   encodeFunctionData(functionFragment: "upgradeTo", values: [string]): string;
   encodeFunctionData(
     functionFragment: "upgradeToAndCall",
@@ -240,6 +248,7 @@ export interface FaucetInterface extends ethers.utils.Interface {
     functionFragment: "maxSwapAmount_unused",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "minTopping", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "nameService",
     data: BytesLike
@@ -273,6 +282,10 @@ export interface FaucetInterface extends ethers.utils.Interface {
     functionFragment: "setGasTopping",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "setMinTopping",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "startTime", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "supportsInterface",
@@ -280,7 +293,6 @@ export interface FaucetInterface extends ethers.utils.Interface {
   ): Result;
   decodeFunctionResult(functionFragment: "topWallet", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "toppings", data: BytesLike): Result;
-  decodeFunctionResult(functionFragment: "upgrade", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "upgradeToAndCall",
@@ -442,6 +454,8 @@ export interface Faucet extends BaseContract {
 
     maxSwapAmount_unused(overrides?: CallOverrides): Promise<[number]>;
 
+    minTopping(overrides?: CallOverrides): Promise<[number]>;
+
     nameService(overrides?: CallOverrides): Promise<[string]>;
 
     notFirstTime(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;
@@ -479,6 +493,11 @@ export interface Faucet extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    setMinTopping(
+      _minTop: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
     startTime(overrides?: CallOverrides): Promise<[BigNumber]>;
 
     supportsInterface(
@@ -497,10 +516,6 @@ export interface Faucet extends BaseContract {
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
-    upgrade(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
     upgradeTo(
       newImplementation: string,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -577,6 +592,8 @@ export interface Faucet extends BaseContract {
 
   maxSwapAmount_unused(overrides?: CallOverrides): Promise<number>;
 
+  minTopping(overrides?: CallOverrides): Promise<number>;
+
   nameService(overrides?: CallOverrides): Promise<string>;
 
   notFirstTime(arg0: string, overrides?: CallOverrides): Promise<boolean>;
@@ -614,6 +631,11 @@ export interface Faucet extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  setMinTopping(
+    _minTop: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   startTime(overrides?: CallOverrides): Promise<BigNumber>;
 
   supportsInterface(
@@ -632,10 +654,6 @@ export interface Faucet extends BaseContract {
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  upgrade(
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   upgradeTo(
     newImplementation: string,
     overrides?: Overrides & { from?: string | Promise<string> }
@@ -712,6 +730,8 @@ export interface Faucet extends BaseContract {
 
     maxSwapAmount_unused(overrides?: CallOverrides): Promise<number>;
 
+    minTopping(overrides?: CallOverrides): Promise<number>;
+
     nameService(overrides?: CallOverrides): Promise<string>;
 
     notFirstTime(arg0: string, overrides?: CallOverrides): Promise<boolean>;
@@ -746,6 +766,11 @@ export interface Faucet extends BaseContract {
       overrides?: CallOverrides
     ): Promise<void>;
 
+    setMinTopping(
+      _minTop: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
     startTime(overrides?: CallOverrides): Promise<BigNumber>;
 
     supportsInterface(
@@ -761,8 +786,6 @@ export interface Faucet extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    upgrade(overrides?: CallOverrides): Promise<void>;
-
     upgradeTo(
       newImplementation: string,
       overrides?: CallOverrides
@@ -911,6 +934,8 @@ export interface Faucet extends BaseContract {
 
     maxSwapAmount_unused(overrides?: CallOverrides): Promise<BigNumber>;
 
+    minTopping(overrides?: CallOverrides): Promise<BigNumber>;
+
     nameService(overrides?: CallOverrides): Promise<BigNumber>;
 
     notFirstTime(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
@@ -948,6 +973,11 @@ export interface Faucet extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    setMinTopping(
+      _minTop: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
     startTime(overrides?: CallOverrides): Promise<BigNumber>;
 
     supportsInterface(
@@ -966,10 +996,6 @@ export interface Faucet extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    upgrade(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
     upgradeTo(
       newImplementation: string,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -1055,6 +1081,8 @@ export interface Faucet extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    minTopping(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     nameService(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     notFirstTime(
@@ -1095,6 +1123,11 @@ export interface Faucet extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    setMinTopping(
+      _minTop: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     startTime(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     supportsInterface(
@@ -1113,10 +1146,6 @@ export interface Faucet extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    upgrade(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
     upgradeTo(
       newImplementation: string,
       overrides?: Overrides & { from?: string | Promise<string> }