@gooddollar/goodprotocol 1.0.27 → 1.0.28

package/scripts/deployFullDAO.ts

@@ -509,19 +509,27 @@ const deployAdminWallet = async identity => {
     hdNode.derivePath(`m/44'/60'/0'/0/${i}`)
   );
 
-  const adminWallet = (await new ethers.ContractFactory(
-    AdminWalletABI.abi,
-    AdminWalletABI.bytecode,
-    root
-  )
-    .deploy(
+  const adminWallet = (await upgrades
+    .deployProxy(await ethers.getContractFactory("AdminWallet"), [
       admins.slice(0, 20).map(_ => _.address),
-      ethers.utils.parseUnits("1000000", "gwei"),
-      4,
+      root.address,
       identity
-    )
+    ])
     .then(printDeploy)) as Contract;
 
+  // const adminWallet = (await new ethers.ContractFactory(
+  //   AdminWalletABI.abi,
+  //   AdminWalletABI.bytecode,
+  //   root
+  // )
+  //   .deploy(
+  //     admins.slice(0, 20).map(_ => _.address),
+  //     ethers.utils.parseUnits("1000000", "gwei"),
+  //     4,
+  //     identity
+  //   )
+  //   .then(printDeploy)) as Contract;
+
   const id = await ethers.getContractAt("IIdentity", identity);
   await id.addIdentityAdmin(adminWallet.address).then(printDeploy);
   await root

package/scripts/multichain-deploy/basicdao-deploy.ts

@@ -1,9 +1,6 @@
 import { network, ethers, upgrades, run } from "hardhat";
-import { isFunction, get, omitBy } from "lodash";
-import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 import pressAnyKey from "press-any-key";
 import { Contract } from "ethers";
-import { range } from "lodash";
 // import DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorGoodDollar.json";
 import DAOCreatorABI from "../../../GoodBootstrap/packages/contracts/build/contracts/DaoCreatorGoodDollarWithRep.json";
 // import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
@@ -11,13 +8,6 @@ import IdentityABI from "../../../GoodBootstrap/packages/contracts/build/contrac
 import FeeFormulaABI from "@gooddollar/goodcontracts/build/contracts/FeeFormula.json";
 // import AddFoundersABI from "@gooddollar/goodcontracts/build/contracts/AddFoundersGoodDollar.json";
 import AddFoundersABI from "../../../GoodBootstrap/packages/contracts/build/contracts/AddFoundersGoodDollarWithRep.json";
-import ContributionCalculation from "@gooddollar/goodcontracts/stakingModel/build/contracts/ContributionCalculation.json";
-import FirstClaimPool from "@gooddollar/goodcontracts/stakingModel/build/contracts/FirstClaimPool.json";
-import BridgeMock from "@gooddollar/goodcontracts/stakingModel/build/contracts/BridgeMock.json";
-import AdminWalletABI from "@gooddollar/goodcontracts/build/contracts/AdminWallet.json";
-import OTPABI from "@gooddollar/goodcontracts/build/contracts/OneTimePayments.json";
-import HomeBridgeABI from "@gooddollar/goodcontracts/build/contracts/DeployHomeBridge.json";
-import ForeignBridgeABI from "@gooddollar/goodcontracts/build/contracts/DeployForeignBridge.json";
 
 import { deployDeterministic } from "./helpers";
 import releaser from "../../scripts/releaser";

package/scripts/test/localOldDaoDeploy.ts

@@ -23,7 +23,6 @@ import FundManager from "@gooddollar/goodcontracts/stakingModel/build/contracts/
 import SimpleDAIStaking from "@gooddollar/goodcontracts/stakingModel/build/contracts/SimpleDAIStaking.json";
 import BridgeMock from "@gooddollar/goodcontracts/stakingModel/build/contracts/BridgeMock.json";
 import DonationsStaking from "@gooddollar/goodcontracts/upgradables/build/contracts/DonationsStaking.json";
-import AdminWalletABI from "@gooddollar/goodcontracts/build/contracts/AdminWallet.json";
 import OTPABI from "@gooddollar/goodcontracts/build/contracts/OneTimePayments.json";
 
 import releaser from "../releaser";
@@ -107,16 +106,11 @@ export const deploy = async (networkName = name, single = false) => {
 
 const deployAdminWallet = async dao => {
   const signers = await ethers.getSigners();
-  const adminWallet = await new ethers.ContractFactory(
-    AdminWalletABI.abi,
-    AdminWalletABI.bytecode,
-    signers[0]
-  ).deploy(
-    signers.slice(0, 10).map(_ => _.address),
-    ethers.utils.parseUnits("1000000", "gwei"),
-    4,
-    dao.identity
+  const adminWallet = await upgrades.deployProxy(
+    await ethers.getContractFactory("AdminWallet"),
+    [signers.slice(0, 20).map(_ => _.address), signers[0].address, dao.identity]
   );
+
   const id = await ethers.getContractAt("IIdentity", dao.identity);
   await id.addIdentityAdmin(adminWallet.address);
   await signers[0].sendTransaction({

package/test/FuseFaucet.test.ts

@@ -128,30 +128,26 @@ describe("FuseFaucet", () => {
   // });
 
   it("should not let user top over weekly limit", async () => {
-    for (let i = 0; i < 3; i++) {
+    for (let i = 0; i < 5; 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: ethers.utils.parseUnits("500000", "gwei")
+        value: ethers.utils.parseUnits("5000000", "gwei")
       });
-      // await (await faucet.topWallet(user1.address)).wait();
-      // await user1.sendTransaction({
-      //   to: ethers.constants.AddressZero,
-      //   value: ethers.utils.parseUnits("500000", "gwei"),
-      // });
     }
-    // await (await faucet.topWallet(user1.address)).wait();
-    // await user1.sendTransaction({
-    //   to: ethers.constants.AddressZero,
-    //   value: ethers.utils.parseUnits("500000", "gwei"),
-    // });
     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"
     );
+
+    //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", []);
+
+    expect(await faucet.canTop(user1.address)).to.true;
   });
 
   it("should reimburse gas costs", async () => {

package/test/utils/AdminWallet.test.ts

@@ -0,0 +1,254 @@
+import { expect } from "chai";
+import { ethers, upgrades, network } from "hardhat";
+import { createDAO } from "../helpers";
+import { Contract } from "ethers";
+import { AdminWallet } from "../../types";
+
+const BN = ethers.BigNumber;
+export const NULL_ADDRESS = ethers.constants.AddressZero;
+export const BLOCK_INTERVAL = 1;
+
+describe("AdminWallet", () => {
+  let signers,
+    adminWallet: AdminWallet,
+    newUser,
+    newUser2,
+    admin,
+    admin2,
+    toWhitelist,
+    toppingTimes,
+    toppingAmount,
+    founder,
+    whitelisted,
+    stranger,
+    stranger2,
+    blacklisted,
+    identity;
+
+  before(async () => {
+    signers = await ethers.getSigners();
+    [founder, whitelisted, stranger, stranger2, blacklisted] = signers;
+    let { identity: id } = await createDAO();
+    identity = await ethers.getContractAt("IIdentity", id);
+
+    adminWallet = (await upgrades.deployProxy(
+      await ethers.getContractFactory("AdminWallet"),
+      [[], signers[0].address, id],
+      { kind: "uups" }
+    )) as AdminWallet;
+
+    identity.addIdentityAdmin(adminWallet.address);
+
+    toppingTimes = await adminWallet.toppingTimes();
+    toppingAmount = await adminWallet.toppingAmount();
+
+    newUser = (await ethers.Wallet.createRandom()).connect(ethers.provider);
+    newUser2 = (await ethers.Wallet.createRandom()).connect(ethers.provider);
+    admin = (await ethers.Wallet.createRandom()).connect(ethers.provider);
+    admin2 = (await ethers.Wallet.createRandom()).connect(ethers.provider);
+    toWhitelist = (await ethers.Wallet.createRandom()).connect(ethers.provider);
+  });
+
+  it("should transfer to admins", async () => {
+    await signers[0].sendTransaction({
+      to: admin.address,
+      value: toppingAmount / 4
+    });
+  });
+
+  it("should fill wallet", async () => {
+    await signers[0].sendTransaction({
+      to: adminWallet.address,
+      value: ethers.utils.parseUnits("50", "ether")
+    });
+  });
+
+  it("should not top admin list when empty", async () => {
+    await expect(adminWallet["topAdmins(uint256)"](0)).revertedWith(
+      "Admin list is empty"
+    );
+  });
+
+  it("should add admins", async () => {
+    await adminWallet.addAdmins(
+      [whitelisted, admin, admin2].map(_ => _.address)
+    );
+    expect(await adminWallet.isAdmin(whitelisted.address)).true;
+    expect(await adminWallet.isAdmin(admin.address)).to.true;
+    expect(await adminWallet.isAdmin(admin2.address)).to.true;
+  });
+
+  it("should top admins", async () => {
+    const oldBalance = await ethers.provider.getBalance(admin2.address);
+    expect(oldBalance).to.be.equal("0");
+
+    await adminWallet["topAdmins(uint256,uint256)"](0, 1); //test topping with indexes
+    await adminWallet["topAdmins(uint256,uint256)"](1, 2);
+    expect(await ethers.provider.getBalance(whitelisted.address)).gt(0);
+    expect(await ethers.provider.getBalance(admin.address)).gt(0);
+    expect(await ethers.provider.getBalance(admin2.address)).eq(0);
+    await adminWallet["topAdmins(uint256)"](0);
+    const newBalance = await ethers.provider.getBalance(admin2.address);
+    const adminTopAmount = await adminWallet
+      .adminToppingAmount()
+      .then(_ => _.toString());
+    expect(newBalance).to.be.equal(adminTopAmount);
+  });
+
+  it("should reimburse gas for admins", async () => {
+    const expectedTopping = await adminWallet
+      .adminToppingAmount()
+      .then(_ => _.toString());
+    const adminWalletBalance = await ethers.provider.getBalance(
+      adminWallet.address
+    );
+    expect(expectedTopping).to.be.equal(
+      ethers.utils.parseUnits("90000000", "gwei")
+    );
+    expect(adminWalletBalance).gt(1);
+    let oldBalance = await ethers.provider.getBalance(admin2.address);
+    let toTransfer = oldBalance.div(2);
+    if (toTransfer.gt(0))
+      await admin2.sendTransaction({
+        to: founder.address,
+        value: toTransfer
+      });
+    oldBalance = await ethers.provider.getBalance(admin2.address);
+    expect(oldBalance).to.be.lte(toTransfer);
+
+    await adminWallet
+      .connect(admin2)
+      .whitelist(toWhitelist.address, "did:test" + Math.random());
+    const newBalance = await ethers.provider.getBalance(admin2.address);
+    expect(newBalance).to.be.gte(expectedTopping);
+  });
+
+  it("should remove single admin", async () => {
+    await adminWallet.removeAdmins([whitelisted.address]);
+    expect(await adminWallet.isAdmin(whitelisted.address)).to.false;
+  });
+
+  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");
+
+    expect(await identity.isWhitelisted(whitelisted.address)).to.true;
+    await adminWallet.connect(admin).removeWhitelist(whitelisted.address);
+    expect(await identity.isWhitelisted(whitelisted.address)).to.false;
+  });
+
+  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")
+    ).revertedWith("Caller is not admin");
+    expect(await identity.isWhitelisted(whitelisted.address)).to.false;
+    await adminWallet.connect(admin).whitelist(whitelisted.address, "did:test");
+    expect(await identity.isWhitelisted(whitelisted.address)).to.true;
+    await expect(
+      adminWallet.connect(stranger).removeWhitelist(whitelisted.address)
+    ).revertedWith("Caller is not admin");
+    expect(await identity.isWhitelisted(whitelisted.address)).to.true;
+  });
+
+  it("should allow admin to blacklist and remove blacklist", async () => {
+    expect(await identity.isBlacklisted(blacklisted.address)).to.false;
+    await adminWallet.connect(admin).blacklist(blacklisted.address);
+
+    expect(await identity.isBlacklisted(blacklisted.address)).to.true;
+    await adminWallet.connect(admin).removeBlacklist(blacklisted.address);
+    expect(await identity.isBlacklisted(blacklisted.address)).to.false;
+  });
+
+  it("should not allow non-admin to blacklist and remove blacklist", async () => {
+    expect(await identity.isBlacklisted(blacklisted.address)).to.false;
+    await expect(
+      adminWallet.connect(stranger).blacklist(blacklisted.address)
+    ).revertedWith("Caller is not admin");
+    expect(await identity.isBlacklisted(blacklisted.address)).to.false;
+    await adminWallet.connect(admin).blacklist(blacklisted.address);
+    expect(await identity.isBlacklisted(blacklisted.address)).to.true;
+    await expect(
+      adminWallet.connect(stranger).removeBlacklist(blacklisted.address)
+    ).revertedWith("Caller is not admin");
+    expect(await identity.isBlacklisted(blacklisted.address)).to.true;
+    await adminWallet.connect(admin).removeBlacklist(blacklisted.address);
+    expect(await identity.isBlacklisted(blacklisted.address)).to.false;
+  });
+
+  it("should not allow to top wallet if user balance is too high", async () => {
+    const walletBalance = await ethers.provider.getBalance(adminWallet.address);
+    const tx = await (
+      await adminWallet.connect(admin).topWallet(whitelisted.address)
+    ).wait();
+    const walletBalanceAfter = await ethers.provider.getBalance(
+      adminWallet.address
+    );
+    expect(walletBalance).eq(walletBalanceAfter);
+    expect(tx.logs.length).eq(0);
+  });
+
+  it("should allow to top wallet", async () => {
+    expect(await ethers.provider.getBalance(newUser.address)).eq(0);
+    await adminWallet.connect(admin).topWallet(newUser.address);
+    expect(await ethers.provider.getBalance(newUser.address)).gt(0);
+    await newUser.sendTransaction({
+      to: adminWallet.address,
+      value: toppingAmount * 0.9
+    });
+  });
+
+  it("should not allow to top wallet more than three times", async () => {
+    await adminWallet.connect(admin).topWallet(newUser.address);
+    await newUser.sendTransaction({
+      to: adminWallet.address,
+      value: toppingAmount * 0.9
+    });
+    await founder.sendTransaction({
+      to: admin2.address,
+      value: toppingAmount / 5
+    });
+    await adminWallet.connect(admin).topWallet(newUser.address);
+    await newUser.sendTransaction({
+      to: adminWallet.address,
+      value: toppingAmount * 0.9
+    });
+
+    await expect(
+      adminWallet.connect(admin).topWallet(newUser.address)
+    ).revertedWith("User wallet has been topped too many times today");
+  });
+
+  it("should whitelist user", async () => {
+    expect(await identity.isWhitelisted(stranger2.address)).to.false;
+    await adminWallet.connect(admin2).whitelist(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")
+    ).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");
+  });
+
+  it("should allow owner to upgrade", async () => {
+    const newver = await (
+      await ethers.getContractFactory("AdminWallet")
+    ).deploy();
+    await expect(adminWallet.connect(founder).upgradeTo(newver.address)).not
+      .reverted;
+
+    await expect(
+      upgrades.upgradeProxy(
+        adminWallet.address,
+        await ethers.getContractFactory("AdminWallet")
+      )
+    ).not.throws;
+  });
+});