@gooddollar/goodprotocol 1.0.29-beta.3 → 1.0.29

package/scripts/multichain-deploy/{3_gdSavings-deploy.ts → gdSavings-deploy.ts}

@@ -19,13 +19,8 @@
 
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract, Signer } from "ethers";
-import { defaultsDeep } from "lodash";
 
-import {
-  deployDeterministic,
-  printDeploy,
-  executeViaGuardian
-} from "./helpers";
+import { deployDeterministic, printDeploy } from "./helpers";
 import releaser from "../../scripts/releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
@@ -38,16 +33,18 @@ import {
 } from "../../types";
 const { name: networkName } = network;
 
+const BLOCKS_PER_YEAR = (12 * 60 * 24 * 365).toString();
+const BLOCK_APY = "1000000007735630000";
+
 export const deploySidechain = async () => {
   const isProduction = networkName.includes("production");
   let release: { [key: string]: any } = dao[networkName];
-  let settings = defaultsDeep(
-    {},
-    ProtocolSettings[networkName],
-    ProtocolSettings["default"]
-  );
 
-  let [root] = await ethers.getSigners();
+  let [root, ...signers] = await ethers.getSigners();
+  const proposer =
+    networkName !== "fuse"
+      ? new ethers.Wallet(process.env.PROPOSER_KEY, ethers.provider)
+      : root; //need proposer with 0.3% of GOOD tokens
 
   console.log("got signers:", {
     networkName,
@@ -81,9 +78,9 @@ export const deploySidechain = async () => {
       },
       [
         release.NameService,
-        ethers.BigNumber.from(settings.savings.blockAPY),
-        ethers.BigNumber.from(settings.savings.blocksPerYear),
-        settings.savings.daysUntilUpgrade
+        ethers.BigNumber.from(BLOCK_APY),
+        ethers.BigNumber.from(BLOCKS_PER_YEAR),
+        networkName === "fuse" ? 7 : 30 //days until upgrade
       ]
     ).then(printDeploy)) as Contract;
 
@@ -98,32 +95,12 @@ export const deploySidechain = async () => {
       release.GoodDollarStaking
     );
   }
-  if (networkName.includes("production"))
-    return console.log(
-      "Skipping proposal/upgrade for production, need to perform manually"
-    );
-
-  await executeProposal(GDSavings.address, Wrapper.address);
-};
 
-const executeProposal = async (
-  savingsAddress: string,
-  wrapperAddress: string
-) => {
-  console.log("executing savings + wrapper proposal");
-  const isProduction = networkName.includes("production");
-  let release: { [key: string]: any } = dao[networkName];
-  savingsAddress = savingsAddress || release.GoodDollarStaking;
-  wrapperAddress = wrapperAddress || release.GoodDollarMintBurnWrapper;
-
-  let [root] = await ethers.getSigners();
-  //on celo we dont need voting yet to deploy it.
-  //dev env dont use voting for test purposes
-  const proposer =
-    !networkName.includes("celo") &&
-    (isProduction || networkName.includes("staging"))
-      ? new ethers.Wallet(process.env.PROPOSER_KEY, ethers.provider)
-      : root; //need proposer with 0.3% of GOOD tokens
+  //create proposal
+  const vm = (await ethers.getContractAt(
+    "CompoundVotingMachine",
+    release.CompoundVotingMachine
+  )) as CompoundVotingMachine;
 
   const ctrl = (await ethers.getContractAt(
     "Controller",
@@ -136,7 +113,7 @@ const executeProposal = async (
   )) as NameService;
 
   const proposalContracts = [
-    wrapperAddress, //MinterWrapper -> add GDSavings
+    Wrapper.address, //MinterWrapper -> add GDSavings
     ctrl.address, //controller -> add MinterWrapper as scheme
     ctrl.address, // controller -> add GDSavings as scheme
     ns.address //nameservice add MinterWrapper
@@ -145,10 +122,10 @@ const executeProposal = async (
   const proposalEthValues = proposalContracts.map(_ => 0);
 
   const proposalFunctionSignatures = [
-    "addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)", //add gooddollarstaking as minter in gooddollarwrapper
-    "registerScheme(address,bytes32,bytes4,address)", //make sure gooddollarwrapper is a registered scheme so it can mint G$ tokens
-    "registerScheme(address,bytes32,bytes4,address)", //make sure gdsavings has generic call so it can perform the upgrade process
-    "setAddress(string,address)" //add gooddollarwrapper in nameservice
+    "addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)",
+    "registerScheme(address,bytes32,bytes4,address)",
+    "registerScheme(address,bytes32,bytes4,address)",
+    "setAddress(string,address)"
   ];
 
   const proposalFunctionInputs = [
@@ -163,12 +140,12 @@ const executeProposal = async (
         "uint32",
         "bool"
       ],
-      [savingsAddress, 0, 0, 30, 0, 0, 0, true]
+      [GDSavings.address, 0, 0, 30, 0, 0, 0, true]
     ), //function addMinter(
     ethers.utils.defaultAbiCoder.encode(
       ["address", "bytes32", "bytes4", "address"],
       [
-        wrapperAddress, //scheme
+        Wrapper.address, //scheme
         ethers.constants.HashZero, //paramshash
         "0x00000001", //permissions - minimal
         release.Avatar
@@ -177,7 +154,7 @@ const executeProposal = async (
     ethers.utils.defaultAbiCoder.encode(
       ["address", "bytes32", "bytes4", "address"],
       [
-        savingsAddress, //scheme
+        GDSavings.address, //scheme
         ethers.constants.HashZero, //paramshash
         "0x000000f1", //permissions - genericcall
         release.Avatar
@@ -185,62 +162,71 @@ const executeProposal = async (
     ),
     ethers.utils.defaultAbiCoder.encode(
       ["string", "address"],
-      ["MINTBURN_WRAPPER", wrapperAddress]
+      ["MINTBURN_WRAPPER", Wrapper.address]
     )
   ];
 
-  if (!isProduction && networkName != "staging") {
-    //on fuse staging also use voting for testing
-    console.log("upgrading via guardian...");
-
-    await executeViaGuardian(
+  if (networkName === "fuse") {
+    return executeViaGuardian(
       proposalContracts,
       proposalEthValues,
       proposalFunctionSignatures,
       proposalFunctionInputs,
       root
     );
-  } else if (isProduction) {
-    console.log("creating proposal...");
-    //create proposal
-    const vm = (await ethers.getContractAt(
-      "CompoundVotingMachine",
-      release.CompoundVotingMachine
-    )) as CompoundVotingMachine;
-
-    await vm
-      .connect(proposer)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        proposalContracts,
-        proposalEthValues,
-        proposalFunctionSignatures,
-        proposalFunctionInputs,
-        "https://discourse.gooddollar.org/t/gip-5-allocating-part-of-ubi-inflation-towards-g-savings-account/114/20"
-      )
-      .then(printDeploy);
   }
 
-  const Controller = await ethers.getContractAt(
-    "Controller",
-    release.Controller
-  );
-  const wrapperDaoPermissions = await Controller.getSchemePermissions(
-    wrapperAddress,
-    release.Avatar
-  );
-  const savingsDaoPermissions = await Controller.getSchemePermissions(
-    savingsAddress,
-    release.Avatar
-  );
-
-  console.log({
-    wrapperDaoPermissions,
-    savingsDaoPermissions
-  });
+  console.log("creating proposal...");
+  await vm
+    .connect(proposer)
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      "https://discourse.gooddollar.org/t/gip-5-allocating-part-of-ubi-inflation-towards-g-savings-account/114/20"
+    )
+    .then(printDeploy);
+};
+
+const executeViaGuardian = async (
+  contracts,
+  ethValues,
+  functionSigs,
+  functionInputs,
+  guardian: Signer
+) => {
+  let release: { [key: string]: any } = dao[networkName];
+  const ctrl = await (
+    await ethers.getContractAt("Controller", release.Controller)
+  ).connect(guardian);
+
+  for (let i = 0; i < contracts.length; i++) {
+    const contract = contracts[i];
+    console.log("executing:", contracts[i], functionSigs[i], functionInputs[i]);
+    const sigHash = ethers.utils
+      .keccak256(ethers.utils.toUtf8Bytes(functionSigs[i]))
+      .slice(0, 10);
+    const encoded = ethers.utils.solidityPack(
+      ["bytes4", "bytes"],
+      [sigHash, functionInputs[i]]
+    );
+    if (contract === ctrl.address) {
+      console.log("executing directly on controller:", sigHash, encoded);
+
+      await guardian
+        .sendTransaction({ to: contract, data: encoded })
+        .then(printDeploy);
+    } else {
+      console.log("executing genericCall:", sigHash, encoded);
+      await ctrl
+        .genericCall(contract, encoded, release.Avatar, ethValues[i])
+        .then(printDeploy);
+    }
+  }
 };
 
 export const main = async () => {
   await deploySidechain().catch(console.log);
-  // await executeProposal(undefined, undefined);
 };
 if (process.argv[1].includes("gdSavings")) main();

package/scripts/multichain-deploy/helpers.ts

@@ -1,5 +1,6 @@
 import { Contract, ContractFactory, Signer } from "ethers";
 import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
 import { TransactionResponse } from "@ethersproject/providers";
 import dao from "../../releases/deployment.json";
 

package/scripts/{upgrades → multichain-deploy}/nonubiDistribution-deploy.ts

@@ -11,15 +11,18 @@
  *  - add to the distributionHelper the GoodDollarMintBurnWrapper contract address on fuse as recipient with 100% bps
  */
 
-import { network, ethers } from "hardhat";
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract, Signer } from "ethers";
 
 import {
   deployDeterministic,
   printDeploy,
   executeViaGuardian
-} from "../multichain-deploy/helpers";
+} from "./helpers";
 import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
+import { deployWrapper } from "./multichainWrapper-deploy";
 import {
   CompoundVotingMachine,
   DistributionHelper,

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,15 +106,9 @@ 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);

package/test/helpers.ts

@@ -55,8 +55,11 @@ export const createDAO = async () => {
     root
   );
 
-  const IdentityFactory = await ethers.getContractFactory("IdentityV2");
-
+  const IdentityFactory = new ethers.ContractFactory(
+    IdentityABI.abi,
+    IdentityABI.bytecode,
+    root
+  );
   const FeeFormulaFactory = new ethers.ContractFactory(
     FeeFormulaABI.abi,
     FeeFormulaABI.bytecode,
@@ -72,16 +75,11 @@ export const createDAO = async () => {
     await ethers.getContractFactory("BancorFormula")
   ).deploy();
   const AddFounders = await AddFoundersFactory.deploy();
-  const Identity = await upgrades.deployProxy(
-    IdentityFactory,
-    [root.address, ethers.constants.AddressZero],
-    { kind: "uups" }
-  );
-
+  const Identity = await IdentityFactory.deploy();
   const daoCreator = await DAOCreatorFactory.deploy(AddFounders.address);
   const FeeFormula = await FeeFormulaFactory.deploy(0);
 
-  // await Identity.setAuthenticationPeriod(365);
+  await Identity.setAuthenticationPeriod(365);
   await daoCreator.forgeOrg(
     "GoodDollar",
     "G$",
@@ -102,7 +100,7 @@ export const createDAO = async () => {
     root
   );
 
-  // await Identity.setAvatar(Avatar.address);
+  await Identity.setAvatar(Avatar.address);
   const controller = await Avatar.owner();
 
   const ccFactory = new ethers.ContractFactory(
@@ -161,8 +159,6 @@ export const createDAO = async () => {
     }
   );
 
-  await Identity.initDAO(nameService.address);
-
   console.log("deploying reserve...");
   let goodReserve = await upgrades.deployProxy(
     await ethers.getContractFactory("GoodReserveCDai"),

package/test/ubi/UBIScheme.test.ts

@@ -127,11 +127,13 @@ describe("UBIScheme", () => {
 
   it("should return zero entitlement before UBI started", async () => {
     let blockTimestamp = (await ethers.provider.getBlock("latest")).timestamp;
-    const timeInDay = blockTimestamp % ONE_DAY;
+    const timeInDay = (blockTimestamp % (ONE_DAY));
     // Move to before 12pm of the current day
     if (timeInDay > 12 * ONE_HOUR) {
       blockTimestamp += 12 * ONE_HOUR;
-      await ethers.provider.send("evm_setNextBlockTimestamp", [blockTimestamp]);
+      await ethers.provider.send("evm_setNextBlockTimestamp", [
+        blockTimestamp
+      ]);
       await ethers.provider.send("evm_mine", []);
     }
     const ubiNew = await deployNewUbi();
@@ -198,26 +200,24 @@ describe("UBIScheme", () => {
     expect(error.message).to.have.string("Only UBIScheme can call this method");
   });
 
-  it("should estimate next daily UBI to according to min value when no claimers and not using first claim pool", async () => {
+  it("should estimate next daily UBI to default value when no claimers and not using first claim pool", async () => {
     const nextDailyUBIBefore = await ubi.estimateNextDailyUBI();
-    const minActiveUsers = await ubi.minActiveUsers();
-    const cycleLength = await ubi.cycleLength();
-    const pool = await goodDollar.balanceOf(ubi.address);
-    const dailyPool = pool.div(cycleLength);
-    const defaultDailyClaim = dailyPool.div(minActiveUsers);
-    let encodedCall = ubi.interface.encodeFunctionData("setUseFirstClaimPool", [
-      false
-    ]);
+    const defaultDailyUbi = await ubi.defaultDailyUbi();
+    let encodedCall = ubi.interface.encodeFunctionData(
+      "setUseFirstClaimPool",
+      [false]
+    );
     await genericCall(ubi.address, encodedCall);
     const nextDailyUBIAfter = await ubi.estimateNextDailyUBI();
 
     expect(nextDailyUBIBefore.eq(0));
     expect(nextDailyUBIAfter.gt(nextDailyUBIBefore));
-    expect(nextDailyUBIAfter.eq(defaultDailyClaim));
+    expect(nextDailyUBIAfter.eq(defaultDailyUbi));
 
-    encodedCall = ubi.interface.encodeFunctionData("setUseFirstClaimPool", [
-      true
-    ]);
+    encodedCall = ubi.interface.encodeFunctionData(
+      "setUseFirstClaimPool",
+      [true]
+    );
     await genericCall(ubi.address, encodedCall);
   });
 
@@ -315,8 +315,8 @@ describe("UBIScheme", () => {
     await genericCall(ubi.address, encodedCall); // we should set cyclelength to one cause this tests was implemented according to it
     const currentDay = await ubi.currentDayInCycle().then(_ => _.toNumber());
     await increaseTime(ONE_DAY);
-    await goodDollar.mint(avatar, "300002");
-    //ubi will have 902GD in pool so daily ubi is now 300002/1(cycle)/1000(min claimers) = 300
+    await goodDollar.mint(avatar, "901");
+    //ubi will have 902GD in pool so daily ubi is now 902/1(cycle)/3(claimers) = 300
     await ubi.connect(claimer1).claim();
     await increaseTime(ONE_DAY);
     await goodDollar.mint(avatar, "1");
@@ -326,8 +326,8 @@ describe("UBIScheme", () => {
     let avatarBalance = await goodDollar.balanceOf(avatar);
     let claimer1Balance = await goodDollar.balanceOf(claimer1.address);
     expect(avatarBalance.toString()).to.be.equal("0");
-    // 300 GD from first day and 299 (30002 - 300 /1 / 1000)  from the second day claimed in this test
-    expect(claimer1Balance.toString()).to.be.equal("599");
+    // 300 GD from first day and 201 from the second day claimed in this test
+    expect(claimer1Balance.toString()).to.be.equal("501");
   });
 
   it("should return the reward value for entitlement user", async () => {
@@ -519,11 +519,11 @@ describe("UBIScheme", () => {
   });
 
   it("distribute formula should return correct value", async () => {
-    await goodDollar.mint(avatar, "20000");
+    await goodDollar.mint(avatar, "20");
     await increaseTime(ONE_DAY);
     let ubiBalance = await goodDollar.balanceOf(ubi.address);
     let avatarBalance = await goodDollar.balanceOf(avatar);
-    let activeUsersCount = await ubi.minActiveUsers(); // await ubi.activeUsersCount();
+    let activeUsersCount = await ubi.activeUsersCount();
     let claimer4BalanceBefore = await goodDollar.balanceOf(claimer2.address);
     await ubi.connect(claimer2).claim();
     let claimer4BalanceAfter = await goodDollar.balanceOf(claimer2.address);
@@ -539,7 +539,7 @@ describe("UBIScheme", () => {
     await increaseTime(ONE_DAY);
     let ubiBalance = await goodDollar.balanceOf(ubi.address);
     let avatarBalance = await goodDollar.balanceOf(avatar);
-    let activeUsersCount = await ubi.minActiveUsers(); // await ubi.activeUsersCount();
+    let activeUsersCount = await ubi.activeUsersCount();
     let claimer4BalanceBefore = await goodDollar.balanceOf(claimer2.address);
     await ubi.connect(claimer2).claim();
     let claimer4BalanceAfter = await goodDollar.balanceOf(claimer2.address);
@@ -565,12 +565,12 @@ describe("UBIScheme", () => {
     let claimer1Balance1 = await goodDollar.balanceOf(claimer1.address);
     // regular claim
     await ubi.connect(claimer1).claim();
+    const ubiGdBalance = await goodDollar.balanceOf(ubi.address);
     let claimer1Balance2 = await goodDollar.balanceOf(claimer1.address);
-    let dailyCyclePool = await ubi.dailyCyclePool();
-    let activeUsersCount = await ubi.minActiveUsers(); // await ubi.activeUsersCount();
-    // the dailyCyclePool  divided by max(activeUser,minActiveUsers) should give the daily claim (diff between ubipool balances)
+    // there are 3 claimers and the total ubi balance after the minting include the previous balance and
+    // the dailyCyclePool is 948439324947 minting tokens. that divides into 3
     expect(claimer1Balance2.sub(claimer1Balance1).toString()).to.be.equal(
-      dailyCyclePool.div(activeUsersCount)
+      BN.from("948439324947").div(3)
     );
   });
 
@@ -627,8 +627,8 @@ describe("UBIScheme", () => {
 
   it("should award first claimer with default value when not using first claim pool", async () => {
     const ubiNew = await deployNewUbi();
-    await goodDollar.mint(ubiNew.address, 1000);
-    const expectedDailyUbi = 1; // 1000 divided by minActiveUsers which is also 1000 by default
+    const defaultDailyUbi = await ubiNew.defaultDailyUbi();
+    await goodDollar.mint(ubiNew.address, defaultDailyUbi);
     await addWhitelisted(claimer8.address, "claimer8");
     const encodedCall = ubiNew.interface.encodeFunctionData(
       "setUseFirstClaimPool",
@@ -638,8 +638,8 @@ describe("UBIScheme", () => {
     const claimerBalanceBefore = await goodDollar.balanceOf(claimer8.address);
     await (await ubiNew.connect(claimer8).claim()).wait();
     const claimerBalanceAfter = await goodDollar.balanceOf(claimer8.address);
-
+    
     expect(claimerBalanceAfter.gt(claimerBalanceBefore));
-    expect(claimerBalanceAfter.sub(claimerBalanceBefore).eq(expectedDailyUbi));
+    expect(claimerBalanceAfter.sub(claimerBalanceBefore).eq(defaultDailyUbi));
   });
 });

package/test/ubi/UBISchemeCycle.test.ts

@@ -125,13 +125,12 @@ describe("UBIScheme cycle", () => {
     expect(
       await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
     ).to.be.equal(10); //10 days passed total
-
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait(); //claims in new ubi cycle
-    let dailyClaimAmount = (await ubiScheme.dailyCyclePool()).div(1000); //initialy we have by default min 1000 active users
-
-    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(
-      dailyClaimAmount.add(1000)
-    ); //intial 10 from first claim pool + daily
+    expect(
+      await goodDollar.balanceOf(claimer1.address).then(_ => _.toNumber())
+    ).to.be.equal(
+      1000 + 58593 //58 amount of new ubicycle
+    );
     const cycleEvent = transaction.events.find(
       e => e.event === "UBICycleCalculated"
     );
@@ -141,8 +140,7 @@ describe("UBIScheme cycle", () => {
     expect(
       await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
     ).to.be.equal(0); //new cycle started
-    //intial balance on cycle start 1000000 - 125(one user that claimed) = 999875, divide by cycle length (8) = 124984
-    expect(cycleEvent.args.dailyUBIPool).to.be.equal(124984);
+    expect(cycleEvent.args.dailyUBIPool).to.be.equal(117187); //pool balance: (1000000 - 62500 given to first claimer) divided by 8 days - only first claimer got 62500 in first cycle
   });
 
   it("should calculate cycle early if we can increase current daily pool", async () => {
@@ -179,7 +177,7 @@ describe("UBIScheme cycle", () => {
     //increase ubi pool balance
     let encoded = goodDollar.interface.encodeFunctionData("mint", [
       ubiScheme.address,
-      100
+      1000
     ]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);

package/test/utils/AdminWallet.test.ts

@@ -39,19 +39,16 @@ describe("AdminWallet", () => {
       admin2,
       toWhitelist
     ] = signers.slice(10);
-    let { identity: id, nameService } = await createDAO();
-    identity = await ethers.getContractAt("IdentityV2", id);
+    let { identity: id } = await createDAO();
+    identity = await ethers.getContractAt("IIdentity", id);
 
     adminWallet = (await upgrades.deployProxy(
       await ethers.getContractFactory("AdminWallet"),
-      [[], nameService.address, signers[0].address, 1e10],
+      [[], signers[0].address, id],
       { kind: "uups" }
     )) as AdminWallet;
 
-    await identity.grantRole(
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
-      adminWallet.address
-    );
+    identity.addIdentityAdmin(adminWallet.address);
 
     toppingTimes = await adminWallet.toppingTimes();
     toppingAmount = await adminWallet.toppingAmount();
@@ -90,12 +87,6 @@ describe("AdminWallet", () => {
     });
   });
 
-  it("should have owner", async () => {
-    expect(
-      await adminWallet.hasRole(ethers.constants.HashZero, signers[0].address)
-    ).to.eq(true);
-  });
-
   it("should not top admin list when empty", async () => {
     await expect(adminWallet["topAdmins(uint256)"](0)).revertedWith(
       "Admin list is empty"
@@ -151,10 +142,7 @@ describe("AdminWallet", () => {
 
     await adminWallet
       .connect(admin2)
-      ["whitelist(address,string)"](
-        toWhitelist.address,
-        "did:test" + Math.random()
-      );
+      .whitelist(toWhitelist.address, "did:test" + Math.random());
     const newBalance = await ethers.provider.getBalance(admin2.address);
     expect(newBalance).to.be.gte(expectedTopping);
   });
@@ -166,9 +154,7 @@ describe("AdminWallet", () => {
 
   it("should allow admin to whitelist and remove whitelist", async () => {
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
-    await adminWallet
-      .connect(admin)
-      ["whitelist(address,string)"](whitelisted.address, "did:test");
+    await adminWallet.connect(admin).whitelist(whitelisted.address, "did:test");
 
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
     await adminWallet.connect(admin).removeWhitelist(whitelisted.address);
@@ -178,14 +164,10 @@ describe("AdminWallet", () => {
   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(address,string)"](whitelisted.address, "did:test")
+      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(address,string)"](whitelisted.address, "did:test");
+    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)
@@ -263,24 +245,20 @@ describe("AdminWallet", () => {
 
   it("should whitelist user", async () => {
     expect(await identity.isWhitelisted(stranger2.address)).to.false;
-    await adminWallet
-      .connect(admin2)
-      ["whitelist(address,string)"](stranger2.address, "did:test3");
+    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(address,string)"](stranger.address, "did:test")
+      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("not owner");
+    ).revertedWith("Ownable: caller is not the owner");
   });
 
   it("should allow owner to upgrade", async () => {