@gooddollar/goodprotocol 1.0.26 → 1.0.29-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "1.0.26",
+  "version": "1.0.29-beta.0",
   "description": "GoodDollar Protocol",
   "scripts": {
     "build": "scripts/build.sh deploy",
@@ -59,7 +59,7 @@
     "@jsier/retrier": "^1.2.4",
     "@openzeppelin/contracts": "^4.5.0",
     "@openzeppelin/contracts-upgradeable": "^4.3.2",
-    "@typechain/hardhat": "^2.2.0",
+    "@typechain/hardhat": "^6.1.2",
     "async-promise-pool": "^1.0.4",
     "ethers-multicall": "^0.2.1",
     "openzeppelin-solidity": "^4.3.2",
@@ -73,10 +73,10 @@
     "@babel/polyfill": "*",
     "@babel/preset-env": "*",
     "@babel/register": "*",
-    "@nomiclabs/hardhat-ethers": "^2.0.5",
-    "@nomiclabs/hardhat-etherscan": "^3.0.3",
+    "@nomiclabs/hardhat-ethers": "^2.1.1",
+    "@nomiclabs/hardhat-etherscan": "^3.1.0",
     "@nomiclabs/hardhat-waffle": "^2.0.3",
-    "@openzeppelin/hardhat-upgrades": "1.7.0",
+    "@openzeppelin/hardhat-upgrades": "^1.20.0",
     "@typechain/ethers-v5": "^8.0.2",
     "@types/mocha": "*",
     "@types/node": "*",
@@ -93,9 +93,9 @@
     "fs-extra": "9.0.0",
     "graphql": "^15.5.0",
     "graphql-request": "^3.4.0",
-    "hardhat": "^2.9.3",
-    "hardhat-contract-sizer": "^2.0.3",
-    "hardhat-gas-reporter": "^1.0.4",
+    "hardhat": "^2.10.2",
+    "hardhat-contract-sizer": "^2.6.1",
+    "hardhat-gas-reporter": "^1.0.8",
     "lodash": "^4.17.21",
     "merkle-tree-solidity": "*",
     "mocha": "^9.1.2",

package/releases/deployment.json

@@ -146,14 +146,16 @@
         "FuseFaucet": "0x09Ad3430D146aa662eA8c20cBEBceBC0bbB3FB0a",
         "Invites": "0x187fc9fB37DF0fbf75149913a97B17c968Fc90d0",
         "OneTimePayments": "0x184C1F83b3eB75a2dac483D4a6b9FBD59Df961f8",
-        "AdminWallet": "0x14204288286823042263156146334B1a4d61227c",
+        "AdminWallet": "0xC1526892198796d30D33355cfF9Af10EED5B86A0",
+        "AdminWalletOld": "0x14204288286823042263156146334B1a4d61227c",
         "network": "fuse",
         "networkId": 122,
         "ProxyFactory": "0x4136dfD47F47792fC820E2354e9F0ce8e9c586A6",
         "BancorFormula": "0x88e111b2A42457655A34896E5B929a75E7B82F88",
         "DAI": "0x0000000000000000000000000000000000000000",
         "cDAI": "0x0000000000000000000000000000000000000000",
-        "COMP": "0x0000000000000000000000000000000000000000"
+        "COMP": "0x0000000000000000000000000000000000000000",
+        "ProxyAdmin": "0x0dd5e1869DA5C9C7D7c49364687534bda7fB7020"
     },
     "fuse-mainnet": {
         "NameService": "0x3baeEff20Cb02a5b8eF413C611c015E69221663e",
@@ -300,9 +302,8 @@
     },
     "staging": {
         "FuseFaucet": "0x70f361EDB97B245E8A68573637A31886A427fe2a",
-        "ProxyAdmin": "0x2Ea4aAA8351CfE63B537E81Cd4a13c435B945C1D",
+        "ProxyAdmin": "0x83EEE673ba91ff49b7e608E761e7Bda93bBB5900",
         "Invites": "0x763b49F901DC894F2dEc1c7d19e46250B4452679",
-        "ProxyAdmin2": "0x23D8492444DA663fcb2bDa8cA9A0e84989D1f59e",
         "GoodDollar": "0xe39236a9Cf13f65DB8adD06BD4b834C65c523d2b",
         "NameService": "0xE63402A7dc11AB4D03c477cc92209463a55A5134",
         "GReputation": "0x80312bad9dd71d3a159e794B7fb1B2386F82F07F",
@@ -316,7 +317,8 @@
         "Controller": "0xb6808120fB648c0bdc483Ec423d933a7eBf6BB0a",
         "AbsoluteVote": "0x7b58A5737440Bc05ca3972fDeFf8ac3bA984536B",
         "SchemeRegistrar": "0x0E79f80809180aB8FAE189D4e76fC814672d9a40",
-        "AdminWallet": "0x2961a6C2Fe39F0FFC4f4b1D9E037CD95f4e9C993",
+        "AdminWallet": "0x11C9dBcA722770E8802F0C3d65C38768E91Ac53C",
+        "AdminWalletOld": "0x2961a6C2Fe39F0FFC4f4b1D9E037CD95f4e9C993",
         "UpgradeScheme": "0xfC9F6F5E3ff7BAAB3fEf82e66f56917D625ba38B",
         "OneTimePayments": "0x7912636D68E5d92708862b38698f764BF1EC297C",
         "network": "staging",
@@ -532,7 +534,8 @@
         "SignupBonus": "0x0000000000000000000000000000000000000000",
         "OneTimePayments": "0xd9Aa86e0Ddb932bD78ab8c71C1B98F83cF610Bd4",
         "Invites": "0xCa2F09c3ccFD7aD5cB9276918Bd1868f2b922ea0",
-        "AdminWallet": "0x9F75dAcB77419b87f568d417eBc84346e134144E",
+        "AdminWallet": "0x9A34822112BC73BDc941C62dCc311Ca905Aef2a3",
+        "AdminWalletOld": "0x9F75dAcB77419b87f568d417eBc84346e134144E",
         "Identity": "0xFa8d865A962ca8456dF331D78806152d3aC5B84F",
         "GoodDollar": "0x495d133B938596C9984d462F007B676bDc57eCEC",
         "Controller": "0xBcE053b99e22158f8B62f4DBFbEdE1f936b2D4e4",

package/scripts/bulkProof.ts

@@ -1,7 +1,6 @@
 import fs from "fs";
 import { chunk } from "lodash";
 import { ethers, upgrades, network } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import GReputationABI from "../artifacts/contracts/governance/GReputation.sol/GReputation.json";
 import BulkProofABI from "../artifacts/contracts/utils/BulkProof.sol/BulkProof.json";
 
@@ -12,14 +11,10 @@ import MerkleTree, {
 import { BigNumber } from "ethers";
 
 console.log({
-  networkNames,
   network: network.name,
   upgrade: process.env.UPGRADE
 });
 const { name: networkName } = network;
-networkNames[1] = networkName;
-networkNames[122] = networkName;
-networkNames[3] = networkName;
 
 export const bulkProof = async () => {
   console.log("signer", await ethers.getSigners());

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,10 +1,6 @@
 import { network, ethers, upgrades, run } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
-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";
@@ -12,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/scripts/upgradeScheme.ts

@@ -1,14 +1,10 @@
 import { ethers, upgrades, network } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import { getSettings, releaser } from "../../scripts/getMigrationSettings";
 import { SchemeRegistrar } from "../types";
 import { getFounders } from "./getFounders";
 
-console.log({ networkNames, network: network.name, upgrade: process.env.UPGRADE });
+console.log({ network: network.name, upgrade: process.env.UPGRADE });
 const { name: networkName } = network;
-networkNames[1] = networkName;
-networkNames[122] = networkName;
-networkNames[3] = networkName;
 
 export const proposeUpgradeScheme = async (daoAddresses, schemeAddress) => {
   console.log("proposing conntract upgrade to DAO", {
@@ -47,7 +43,10 @@ export const voteUpgradeScheme = async (network, daoAddresses, proposalId) => {
   );
 
   const founders = await getFounders(network);
-  console.log("voteUpgradeScheme", { absoluteVote: absoluteVote.address, founders });
+  console.log("voteUpgradeScheme", {
+    absoluteVote: absoluteVote.address,
+    founders
+  });
   await Promise.all(
     founders.slice(0, Math.ceil(founders.length / 2)).map(f =>
       absoluteVote
@@ -59,12 +58,8 @@ export const voteUpgradeScheme = async (network, daoAddresses, proposalId) => {
 };
 
 const main = async () => {
-  const {
-    daoAddresses,
-    modelAddresses,
-    upgradableAddresses,
-    founders
-  } = await getSettings(networkName);
+  const { daoAddresses, modelAddresses, upgradableAddresses, founders } =
+    await getSettings(networkName);
 
   // const implementation = "0x7fca2b3e1047291f65c2c914083d970c027f4290";
   // const deployedProxy = upgradableAddresses.FuseStaking;

package/scripts/upgradeToV2/upgradeToV2.ts

@@ -8,7 +8,6 @@
  */
 
 import { network, ethers, upgrades, run } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import { isFunction, get, omitBy } from "lodash";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 import pressAnyKey from "press-any-key";
@@ -53,7 +52,6 @@ const countTotalGas = async (tx, name) => {
 };
 
 console.log({
-  networkNames,
   network: network.name,
   upgrade: process.env.UPGRADE
 });
@@ -64,12 +62,6 @@ export const main = async (
   isPerformUpgrade = true,
   olddao?
 ): Promise<{ [key: string]: any }> => {
-  if (networkName.startsWith("dapptest") === false) {
-    networkNames[1] = networkName;
-    networkNames[122] = networkName;
-    networkNames[3] = networkName;
-  }
-
   const isProduction = networkName.startsWith("production");
   if (isProduction && networkName.includes("mainnet")) {
     GAS_SETTINGS.gasLimit = 6000000;

package/scripts/upgradeToV2/upgradeToV2Recover.ts

@@ -8,7 +8,6 @@
  */
 
 import { network, ethers, upgrades, run } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import { isFunction, get, omitBy } from "lodash";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 
@@ -53,7 +52,6 @@ const countTotalGas = async (tx, name) => {
 };
 
 console.log({
-  networkNames,
   network: network.name,
   upgrade: process.env.UPGRADE
 });
@@ -64,12 +62,6 @@ export const main = async (
   isPerformUpgrade = true,
   olddao?
 ): Promise<{ [key: string]: any }> => {
-  if (networkName.startsWith("dapptest") === false) {
-    networkNames[1] = networkName;
-    networkNames[122] = networkName;
-    networkNames[3] = networkName;
-  }
-
   const isProduction = networkName.startsWith("production");
   if (isProduction && networkName.includes("mainnet")) {
     GAS_SETTINGS.gasLimit = 6000000;

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,278 @@
+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,
+      newUser,
+      newUser2,
+      admin,
+      admin2,
+      toWhitelist
+    ] = 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();
+    const startBalance = await ethers.provider.getBalance(newUser.address);
+    await Promise.all(
+      [newUser, newUser2, admin, admin2, toWhitelist].map(acc =>
+        acc.sendTransaction({
+          to: ethers.constants.AddressZero,
+          value: startBalance.sub(ethers.BigNumber.from("21000000000000")),
+          gasLimit: 21000,
+          gasPrice: 1e9
+        })
+      )
+    );
+  });
+
+  it("should have zero balance for test accouts", async () => {
+    await Promise.all(
+      [newUser, newUser2, admin, admin2, toWhitelist].map(async acc => {
+        expect(await ethers.provider.getBalance(acc.address)).eq(0);
+      })
+    );
+  });
+
+  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;
+  });
+});

package/test/utils/ProtocolUpgrade.test.ts

@@ -2,7 +2,6 @@ import { default as hre, ethers, upgrades, network } from "hardhat";
 import { BigNumber, Contract, Signer } from "ethers";
 import { deployMockContract, MockContract } from "ethereum-waffle";
 import { expect } from "chai";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
 import { deploy } from "../../scripts/test/localOldDaoDeploy";
 import deploySettings from "../../releases/deploy-settings.json";
@@ -66,9 +65,7 @@ describe("ProtocolUpgrade - Upgrade old protocol contracts to new ones", () => {
     fuseController,
     goodReserve;
   const { name: networkName } = network;
-  networkNames[1] = networkName;
-  networkNames[122] = networkName;
-  networkNames[3] = networkName;
+
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();