@gooddollar/goodprotocol 2.0.2 → 2.0.3

package/scripts/multichain-deploy/4_ubi-deploy.ts

@@ -5,24 +5,23 @@
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract } from "ethers";
 import { defaultsDeep } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 import {
   deployDeterministic,
   executeViaGuardian,
   executeViaSafe,
+  verifyContract,
   verifyProductionSigner
 } from "./helpers";
 import releaser from "../releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 import { TransactionResponse } from "@ethersproject/providers";
-import { InvitesV1__factory } from "../../types";
 import { keccak256, toUtf8Bytes } from "ethers/lib/utils";
 
 const { name } = network;
 
-const printDeploy = async (
-  c: Contract | TransactionResponse
-): Promise<Contract | TransactionResponse> => {
+const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
   if (c instanceof Contract) {
     await c.deployed();
     console.log("deployed to: ", c.address);
@@ -35,16 +34,14 @@ const printDeploy = async (
 };
 
 export const deployHelpers = async () => {
-  let protocolSettings = defaultsDeep(
-    {},
-    ProtocolSettings[network.name],
-    ProtocolSettings["default"]
-  );
+  const viaGuardians = false;
+
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
   let release: { [key: string]: any } = dao[network.name];
 
   let [root, ...signers] = await ethers.getSigners();
   const isProduction = network.name.includes("production");
-  const viaGuardians = false;
+
   if (isProduction) verifyProductionSigner(root);
   //generic call permissions
   let schemeMock = root;
@@ -53,9 +50,7 @@ export const deployHelpers = async () => {
     network,
     root: root.address,
     schemeMock: schemeMock.address,
-    balance: await ethers.provider
-      .getBalance(root.address)
-      .then(_ => _.toString())
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
   });
 
   console.log("deploying ubi pool");
@@ -64,19 +59,14 @@ export const deployHelpers = async () => {
       name: "UBIScheme",
       isUpgradeable: true
     },
-    [
-      release.NameService,
-      ethers.constants.AddressZero,
-      protocolSettings.ubi.maxInactiveDays
-    ]
+    [release.NameService, ethers.constants.AddressZero, protocolSettings.ubi.maxInactiveDays]
   ).then(printDeploy)) as Contract;
 
   console.log("deploying claimers distribution");
 
-  const ClaimersDistribution = (await deployDeterministic(
-    { name: "ClaimersDistribution", isUpgradeable: true },
-    [release.NameService]
-  ).then(printDeploy)) as Contract;
+  const ClaimersDistribution = (await deployDeterministic({ name: "ClaimersDistribution", isUpgradeable: true }, [
+    release.NameService
+  ]).then(printDeploy)) as Contract;
 
   console.log("setting nameservice addresses via guardian");
   const proposalContracts = [
@@ -93,10 +83,7 @@ export const deployHelpers = async () => {
     ethers.utils.defaultAbiCoder.encode(
       ["bytes32[]", "address[]"],
       [
-        [
-          keccak256(toUtf8Bytes("UBISCHEME")),
-          keccak256(toUtf8Bytes("GDAO_CLAIMERS"))
-        ],
+        [keccak256(toUtf8Bytes("UBISCHEME")), keccak256(toUtf8Bytes("GDAO_CLAIMERS"))],
         [UBIScheme.address, ClaimersDistribution.address]
       ]
     )
@@ -106,17 +93,14 @@ export const deployHelpers = async () => {
     console.log("minting G$s to pool on dev envs");
     const gd = await ethers.getContractAt("IGoodDollar", release.GoodDollar);
     const decimals = await gd.decimals();
-    await gd.mint(
-      UBIScheme.address,
-      ethers.BigNumber.from(1e6).mul(ethers.BigNumber.from("10").pow(decimals))
-    ); //1million GD
+    await gd.mint(UBIScheme.address, ethers.BigNumber.from(1e6).mul(ethers.BigNumber.from("10").pow(decimals))); //1million GD
   }
 
-  release = {
-    UBIScheme: UBIScheme.address,
-    ClaimersDistribution: ClaimersDistribution.address
-  };
-  await releaser(release, network.name, "deployment", false);
+  let impl = await getImplementationAddress(ethers.provider, UBIScheme.address);
+  await verifyContract(impl, "UBIScheme", network.name);
+
+  impl = await getImplementationAddress(ethers.provider, ClaimersDistribution.address);
+  await verifyContract(impl, "ClaimersDistribution", network.name);
 
   try {
     if (viaGuardians) {

package/scripts/multichain-deploy/helpers.ts

@@ -207,7 +207,7 @@ export const executeViaSafe = async (
       txServiceUrl = "https://safe-transaction-mainnet.safe.global";
       break;
     case 122:
-      txServiceUrl = "https://gateway.safe.fuse.io";
+      txServiceUrl = "https://transaction-fuse.safe.fuse.io";
       break;
     case 42220:
       txServiceUrl = "https://mainnet-tx-svc.celo-safe-prod.celo-networks-dev.org";
@@ -236,8 +236,8 @@ export const executeViaSafe = async (
     const contract = contracts[i];
 
     const sigHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(functionSigs[i])).slice(0, 10);
+    console.log("creating tx:", contracts[i], functionSigs[i], functionInputs[i]);
     const encoded = ethers.utils.solidityPack(["bytes4", "bytes"], [sigHash, functionInputs[i]]);
-    console.log("creating tx:", contracts[i], functionSigs[i], functionInputs[i], encoded);
     if (contract === ctrl.address) {
       const simulationResult =
         isSimulation === false &&

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

@@ -1,7 +1,8 @@
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract } from "ethers";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 
-import { deployDeterministic, printDeploy } from "./helpers";
+import { deployDeterministic, printDeploy, verifyContract } from "./helpers";
 import releaser from "../../scripts/releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
@@ -20,9 +21,7 @@ export const deployWrapper = async (defaultAdmin = null) => {
     network,
     root: root.address,
     schemeMock: schemeMock.address,
-    balance: await ethers.provider
-      .getBalance(root.address)
-      .then(_ => _.toString())
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
   });
 
   console.log("MintBurnWrapper deploy params:", [
@@ -44,6 +43,10 @@ export const deployWrapper = async (defaultAdmin = null) => {
     GoodDollarMintBurnWrapper: Wrapper.address
   };
   await releaser(release, network.name, "deployment", false);
+
+  const impl = await getImplementationAddress(ethers.provider, Wrapper.address);
+  await verifyContract(impl, "GoodDollarMintBurnWrapper", network.name);
+
   return Wrapper;
 };
 

package/scripts/upgradeToV3/v3-fuse-multichain.ts

@@ -0,0 +1,117 @@
+/***
+ * This script will deploy a reserve upgrade and the DistributionHelper so that some of the expansion can be allocated
+ * for non-ubi purposes
+ * Upgrade process:
+ * mainnet:
+ * - deploy reserve
+ * - deploy distributionHelper
+ * - create proposal that:
+ *  - upgrades the reserve
+ *  - sets the distributionHelper at reserve with the agreed bps
+ *  - add to the distributionHelper the contracts addresses to receive part of the UBI
+ */
+
+import { network, ethers } from "hardhat";
+import { defaultsDeep } from "lodash";
+import {
+  deployDeterministic,
+  printDeploy,
+  executeViaGuardian,
+  executeViaSafe,
+  verifyProductionSigner
+} from "../multichain-deploy/helpers";
+import { deployWrapper } from "../multichain-deploy/multichainWrapper-deploy";
+
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { BigNumber } from "ethers";
+const { name: networkName } = network;
+
+export const deployFuse = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let executionMethod = "safe";
+
+  const networkKey = networkName === "localhost" ? "production-mainnet" : networkName;
+  let release: { [key: string]: any } = dao[networkKey];
+  let settings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+  console.log("got signers:", {
+    networkName,
+    networkKey,
+    root: root.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  });
+
+  const Wrapper = await deployWrapper();
+  // const Wrapper = await ethers.getContractAt("GoodDollarMintBurnWrapper", release.GoodDollarMintBurnWrapper);
+
+  const proposalContracts = [
+    release.NameService, //nameservice add Wrapper,MultiChainRouter
+    release.GoodDollar, // give mint rights to Wrapper
+    Wrapper.address //add multichainrouter as minter
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setAddresses(bytes32[],address[])",
+    "addMinter(address)",
+    "addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(
+      ["bytes32[]", "address[]"],
+      [
+        [
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MINTBURN_WRAPPER")),
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MULTICHAIN_ROUTER"))
+        ],
+        [Wrapper.address, release.MultichainRouter]
+      ]
+    ), //setAddresses(bytes32[],address[])"
+    ethers.utils.defaultAbiCoder.encode(["address"], [Wrapper.address]), //addMinter(address)
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint256", "uint256", "uint32", "uint256", "uint256", "uint32", "bool"],
+      [
+        release.MultichainRouter,
+        0,
+        0,
+        0,
+        0,
+        300 * 1e6 * 100, //300M G$ 2 decimals
+        1000, //10%
+        false
+      ]
+    ) //addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)
+  ];
+
+  if (executionMethod === "safe") {
+    return executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      networkName === "localhost" ? "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec" : release.GuardiansSafe,
+      "fuse"
+    );
+  } else {
+    return executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+};
+
+export const main = async () => {
+  await deployFuse().catch(console.log);
+};
+if (process.argv[1].includes("v3-fuse-multichain")) main();

package/scripts/upgrades/celo-defi-ubi-deploy.ts

@@ -3,10 +3,15 @@
  * - upgrade Identity on Fuse to support whitelisting with chainid
  *
  * Step 2:
+ * - deploy 2_helpers on Celo
+ * - add 1000 celo to adminwallet and faucet
+ * - monitor adminwallet + faucet on defender
+ *
+ * Step 3: (once guardians sign Identity upgrade)
  * - upgrade AdminWallet+Invites+Faucet on Fuse to support whitelisting chainid
  * - upgrade backend server to support whitelisting with chainid
  *
- * Step 3:
+ * Step 4:
  * 0. deploy 3_gdStaking, deploy 4_ubi
  * 1. guardians vote send X% to celo ubi pool
  * 2. guardians vote on celo set new GOOD distribution for gdstaking + claiming ubi
@@ -29,6 +34,7 @@ import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 import { upgrade as identityUpgrade } from "./identity-upgrade";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
+import { deployHelpers } from "../multichain-deploy/2_helpers-deploy";
 
 const { name: networkName } = network;
 const isProduction = networkName.includes("production");
@@ -40,6 +46,10 @@ const step1 = async () => {
 };
 
 const step2 = async () => {
+  await deployHelpers();
+};
+
+const step3 = async () => {
   let release: { [key: string]: any } = dao[networkName];
   let [root] = await ethers.getSigners();
 
@@ -67,7 +77,7 @@ const step2 = async () => {
   console.log("upgrade backend contracts abi + call whitelist with chainid....");
 };
 
-const step3 = async () => {
+const step4 = async () => {
   //   let [root, ...signers] = await ethers.getSigners();
 
   const isSafeSimulation = process.env.SAFE_SIMULATION === "true";
@@ -160,6 +170,9 @@ const main = async () => {
     case "3":
       await step3();
       break;
+    case "4":
+      await step4();
+      break;
   }
 };
 main().catch(e => console.error(e));

package/scripts/upgrades/identity-upgrade.ts

@@ -3,6 +3,7 @@
  * Upgrade Plan:
  * - deploy Identity
  * - give adminWallet admin permissions
+ * - give new identy admin permissions in old identity
  * - revoke deployer permissions
  * - replace pointers to old identity contract in:
  *    - GoodDollar token
@@ -10,9 +11,10 @@
  */
 
 import { network, ethers } from "hardhat";
-import { Contract, Signer } from "ethers";
+import { Contract } from "ethers";
 import { defaultsDeep } from "lodash";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+import OldIdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.min.json";
 
 import {
   deployDeterministic,
@@ -41,56 +43,71 @@ export const upgrade = async () => {
   console.log("got signers:", {
     networkName,
     root: root.address,
-    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString()),
+    Identity: release.Identity
   });
 
+  let OldIdentity = await ethers.getContractAt(OldIdentityABI.abi, release.IdentityOld || release.Identity);
   // let Identity = await ethers.getContractAt("IdentityV2", release.Identity);
   // Identity = await ethers.getContractAt("IdentityV2", "0xb0cD4828Cc90C5BC28f4920Adf2Fd8F025003D7E");
-  console.log("deploying new identity...");
+  console.log("deploying new identity...", { old: OldIdentity.address });
   let Identity = (await deployDeterministic(
     {
       name: "IdentityV2",
       salt: "IdentityV2",
       isUpgradeable: true
     },
-    [root.address, release.Identity]
+    [root.address, OldIdentity.address]
   ).then(printDeploy)) as Contract;
 
   let torelease = {
     Identity: Identity.address,
-    IdentityOld: release.Identity
+    IdentityOld: OldIdentity.address
   };
 
   await releaser(torelease, networkName, "deployment", false);
 
   console.log("calling initDAO...");
-  const tx = await (await Identity.initDAO(release.NameService)).wait();
+  const tx = await Identity.initDAO(release.NameService).then(printDeploy);
+  await Identity.grantRole(
+    ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
+    release.AdminWallet
+  ).then(printDeploy);
+
+  //done via Avatar in proposal
+  // await OldIdentity.addIdentityAdmin(Identity.address).then(printDeploy);
+
   const impl = await getImplementationAddress(ethers.provider, Identity.address);
   await verifyContract(impl, "IdentityV2", networkName);
 
   const proposalContracts = [
     release.GoodDollar, //controller -> set new identity in G$
-    release.NameService //nameservice modify to new Identity
+    release.NameService, //nameservice modify to new Identity
+    OldIdentity.address // add new Identity as admin in old identity
   ];
 
   const proposalEthValues = proposalContracts.map(_ => 0);
 
   const proposalFunctionSignatures = [
     "setIdentity(address)", //set Identity on GoodDollar token
-    "setAddress(string,address)" //set new identity address in nameservice
+    "setAddress(string,address)", //set new identity address in nameservice
+    "addIdentityAdmin(address)"
   ];
 
   const proposalFunctionInputs = [
     ethers.utils.defaultAbiCoder.encode(["address"], [Identity.address]),
-    ethers.utils.defaultAbiCoder.encode(["string", "address"], ["IDENTITY", Identity.address])
+    ethers.utils.defaultAbiCoder.encode(["string", "address"], ["IDENTITY", Identity.address]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [Identity.address])
   ];
+
   if (isProduction) {
     await executeViaSafe(
       proposalContracts,
       proposalEthValues,
       proposalFunctionSignatures,
-      proposalFunctionSignatures,
-      protocolSettings.guardiansSafe
+      proposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "fuse"
     );
   } else {
     await executeViaGuardian(

package/test/faucet/Faucet.test.ts

@@ -67,7 +67,7 @@ describe("Faucet", () => {
     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.toppingAmount());
+    expect(balance).to.equal(await faucet.getToppingAmount());
   });
 
   it("should not let new user top more than once", async () => {
@@ -98,7 +98,7 @@ describe("Faucet", () => {
     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.toppingAmount());
+    expect(balance).to.equal(await faucet.getToppingAmount());
   });
 
   it("should not let identified user top over daily limit", async () => {
@@ -123,12 +123,13 @@ describe("Faucet", () => {
   // });
 
   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();
       await user1.sendTransaction({
         to: ethers.constants.AddressZero,
-        value: ethers.utils.parseUnits("5000000", "gwei")
+        value: toppingAmount.mul(80).div(100)
       });
     }
     await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);

package/test/faucet/FuseFaucet.test.ts

@@ -13,17 +13,18 @@ describe("FuseFaucet", () => {
   let user2 = ethers.Wallet.createRandom().connect(ethers.provider);
   let signers;
 
-  let avatar, gd: IGoodDollar, Controller, id: IIdentity;
+  let avatar, gd: IGoodDollar, Controller, id: IIdentity, ns;
 
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
 
     const FuseFaucetF = await ethers.getContractFactory("FuseFaucet");
 
-    let { daoCreator, controller, avatar: av, gd: gooddollar, identity } = await loadFixture(createDAO);
+    let { daoCreator, controller, avatar: av, gd: gooddollar, identity, nameService } = await loadFixture(createDAO);
 
     Controller = controller;
     avatar = av;
+    ns = nameService.address;
 
     // await daoCreator.setSchemes(
     //   avatar,
@@ -54,10 +55,10 @@ describe("FuseFaucet", () => {
     const res = await upgrades.upgradeProxy(faucet.address, await ethers.getContractFactory("FuseFaucetV2"), {
       kind: "transparent",
       unsafeAllowRenames: true,
-      call: { fn: "upgrade", args: [signers[1].address, founder.address] }
+      call: { fn: "upgrade", args: [signers[1].address, founder.address, ns] }
     });
     expect(res).not.empty;
-    await expect(res.upgrade(signers[0].address, signers[0].address)).revertedWith("already upgraded");
+    await expect(res.upgrade(signers[0].address, signers[0].address, ns)).revertedWith("wrong upgrade version");
     expect(await res.owner()).equal(founder.address);
     expect(await res.relayer()).equal(signers[1].address);
   });

package/test/ubi/UBISchemeCycle.test.ts

@@ -13,19 +13,10 @@ const ONE_DAY = 86400;
 describe("UBIScheme cycle", () => {
   let goodDollar, firstClaimPool;
   let reputation;
-  let root,
-    acct,
-    claimer1,
-    claimer2,
-    claimer3,
-    signers,
-    nameService,
-    genericCall,
-    ubiScheme: UBIScheme;
+  let root, acct, claimer1, claimer2, claimer3, signers, nameService, genericCall, ubiScheme: UBIScheme;
 
   before(async () => {
-    [root, acct, claimer1, claimer2, claimer3, ...signers] =
-      await ethers.getSigners();
+    [root, acct, claimer1, claimer2, claimer3, ...signers] = await ethers.getSigners();
 
     const deployedDAO = await loadFixture(createDAO);
     let {
@@ -53,8 +44,8 @@ describe("UBIScheme cycle", () => {
     // await increaseTime(60 * 60 * 24);
   });
 
-  it("should deploy the ubi with default cycle of 90 days", async () => {
-    expect(await ubiScheme.cycleLength()).to.equal(90);
+  it("should deploy the ubi with default cycle of 30 days", async () => {
+    expect(await ubiScheme.cycleLength()).to.equal(30);
   });
 
   it("should not be able to change cycleLength if not avatar", async () => {
@@ -64,9 +55,7 @@ describe("UBIScheme cycle", () => {
 
   it("should be able to change cycleLength if avatar", async () => {
     // initializing the ubi
-    let encodedCall = ubiScheme.interface.encodeFunctionData("setCycleLength", [
-      8
-    ]);
+    let encodedCall = ubiScheme.interface.encodeFunctionData("setCycleLength", [8]);
     await genericCall(ubiScheme.address, encodedCall);
     expect(await ubiScheme.cycleLength()).to.be.equal(8);
   });
@@ -81,10 +70,7 @@ describe("UBIScheme cycle", () => {
 
   it("should set ubischeme", async () => {
     // initializing the ubi
-    let encodedCall = firstClaimPool.interface.encodeFunctionData(
-      "setUBIScheme",
-      [ubiScheme.address]
-    );
+    let encodedCall = firstClaimPool.interface.encodeFunctionData("setUBIScheme", [ubiScheme.address]);
 
     await genericCall(firstClaimPool.address, encodedCall);
     // await firstClaimPool.start();
@@ -98,9 +84,7 @@ describe("UBIScheme cycle", () => {
     let currentCycle = await ubiScheme.currentCycleLength();
     let balance = await goodDollar.balanceOf(ubiScheme.address);
     expect(currentCycle.toNumber()).to.be.gt(0);
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     expect(cycleEvent.args.day.toNumber()).to.be.a("number");
     expect(cycleEvent.args.pool).to.be.equal(balance);
     expect(cycleEvent.args.cycleLength).to.be.equal(cycleLength);
@@ -110,48 +94,33 @@ describe("UBIScheme cycle", () => {
   it("should  have calculated dailyCyclePool and dailyUbi correctly", async () => {
     increaseTime(ONE_DAY);
     let transaction = await ubiScheme.connect(claimer2).claim();
-    expect(
-      await goodDollar.balanceOf(claimer2.address).then(_ => _.toNumber())
-    ).to.be.equal(1000 + (await ubiScheme.dailyUbi().then(_ => _.toNumber()))); //first day 10G$ (1000 wei), second claim 125000 wei daily pool divided by 2 active users = 625000
-    expect(
-      await ubiScheme.dailyCyclePool().then(_ => _.toNumber())
-    ).to.be.equal(125000);
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(1); //1 day passed
+    expect(await goodDollar.balanceOf(claimer2.address).then(_ => _.toNumber())).to.be.equal(
+      1000 + (await ubiScheme.dailyUbi().then(_ => _.toNumber()))
+    ); //first day 10G$ (1000 wei), second claim 125000 wei daily pool divided by 2 active users = 625000
+    expect(await ubiScheme.dailyCyclePool().then(_ => _.toNumber())).to.be.equal(125000);
+    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(1); //1 day passed
   });
 
   it("should calculate next cycle even if day passed without claims(setDay)", async () => {
     increaseTime(ONE_DAY * 9);
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(10); //10 days passed total
+    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
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(dailyClaimAmount.add(1000)); //intial 10 from first claim pool + daily
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
 
     expect(cycleEvent).to.be.not.empty;
 
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(0); //new cycle started
+    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);
   });
 
   it("should calculate cycle early if we can increase current daily pool", async () => {
     //increase ubi pool balance
-    let encoded = goodDollar.interface.encodeFunctionData("mint", [
-      ubiScheme.address,
-      400000
-    ]);
+    let encoded = goodDollar.interface.encodeFunctionData("mint", [ubiScheme.address, 400000]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);
 
@@ -164,9 +133,7 @@ describe("UBIScheme cycle", () => {
     const estimated = await ubiScheme.estimateNextDailyUBI();
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     const dailyUBI = await ubiScheme.dailyUbi();
     expect(dailyUBI).to.eq(estimated); //the estimated before actual calculation should be correct, ie equal to actual dailyUBI calculated after first claim.
     expect(cycleEvent).to.be.not.empty;
@@ -178,10 +145,7 @@ describe("UBIScheme cycle", () => {
 
   it("should not calculate cycle early if not possible to increase daily ubi pool", async () => {
     //increase ubi pool balance
-    let encoded = goodDollar.interface.encodeFunctionData("mint", [
-      ubiScheme.address,
-      100
-    ]);
+    let encoded = goodDollar.interface.encodeFunctionData("mint", [ubiScheme.address, 100]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);
     const curCycleLen = await ubiScheme.cycleLength();
@@ -191,9 +155,7 @@ describe("UBIScheme cycle", () => {
 
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     expect(cycleEvent).to.be.undefined;
   });
 });