@gooddollar/goodprotocol 2.0.5-beta.1 → 2.0.5-beta.10

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/truffle-config.js

@@ -74,6 +74,12 @@ module.exports = {
       timeoutBlocks: 200, // # of blocks before a deployment times out  (minimum/default: 50)
       skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
     },
+    goerli: {
+      provider: () => new Web3.providers.HttpProvider(`https://rpc.ankr.io/eth_goerli`),
+      network_id: 5, // Ropsten's id
+      gas: 3000000, // Ropsten has a lower block limit than mainnet
+      skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
+    },
     fuse: {
       provider: () => new Web3.providers.HttpProvider(`https://rpc.fuse.io`),
       network_id: 122, // Ropsten's id

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