@gooddollar/goodprotocol 1.0.24 → 1.0.26

package/scripts/misc/faucetStats.ts

@@ -0,0 +1,103 @@
+import { range, sortBy, toPairs } from "lodash";
+import fetch from "node-fetch";
+import PromisePool from "async-promise-pool";
+import fs from "fs";
+import { ethers } from "hardhat";
+import { start } from "repl";
+import { JsonRpcProvider } from "@ethersproject/providers";
+import { off } from "process";
+
+function arrayToCsv(data) {
+  return data
+    .map(
+      row =>
+        row
+          .map(String) // convert every value to String
+          .map(v => v.replaceAll('"', '""')) // escape double colons
+          .map(v => `"${v}"`) // quote it
+          .join(",") // comma-separated
+    )
+    .join("\r\n"); // rows starting on new lines
+}
+
+const main = async () => {
+  const archive = new JsonRpcProvider("https://explorer-node.fuse.io");
+  const blockStep = 10000;
+  const pool = new PromisePool({ concurrency: 10 });
+
+  let faucet = await ethers.getContractAt(
+    ["event WalletTopped(address indexed user, uint256 amount)"],
+    "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9"
+  );
+  const endBlock = Number(await ethers.provider.getBlockNumber());
+  const daysBack = 30;
+  const dayBlocks = 12 * 60 * 24;
+  const startBlock = endBlock - dayBlocks * daysBack;
+  const days = range(startBlock, endBlock, dayBlocks);
+  const dailyBalance = [];
+  for (let day of days) {
+    dailyBalance.push(
+      (
+        await archive.getBalance(
+          "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9",
+          day
+        )
+      )
+        .div(1e10)
+        .toNumber() / 1e8
+    );
+  }
+  let curBlock = startBlock;
+
+  const toppingsByAddress = {};
+  const toppingsByAmount = {};
+  let totalToppings = 0;
+  let totalAmount = 0;
+  console.log({ dailyBalance });
+  console.log({ startBlock, endBlock });
+  while (curBlock <= endBlock) {
+    const fromBlock = curBlock;
+    const toBlock = Math.min(fromBlock + blockStep, endBlock);
+    pool.add(async () => {
+      const f = faucet.filters.WalletTopped();
+      const events = await faucet
+        .queryFilter(f, fromBlock, toBlock)
+        .catch(e => {
+          console.log("failed", { fromBlock, toBlock });
+          return [];
+        });
+      events.forEach(e => {
+        totalToppings += 1;
+        totalAmount += Number(e.args.amount);
+        toppingsByAddress[e.args.user] =
+          (toppingsByAddress[e.args.user] || 0) + 1;
+        toppingsByAmount[e.args.amount] =
+          (toppingsByAmount[e.args.amount] || 0) + 1;
+      });
+      console.log("fetched events", {
+        fromBlock,
+        toBlock,
+        events: events.length
+      });
+    });
+    curBlock += blockStep;
+  }
+  await pool.all();
+
+  const topToppers = sortBy(toPairs(toppingsByAddress), "1").reverse();
+  const topAmounts = sortBy(toPairs(toppingsByAmount), "1").reverse();
+  const totalWallets = topToppers.length;
+
+  const avgToppingsPerWallet = totalToppings / totalWallets;
+  const avgToppingAmount = totalAmount / totalToppings;
+
+  fs.writeFileSync("topToppers.csv", arrayToCsv(topToppers));
+  fs.writeFileSync("topAmounts.csv", arrayToCsv(topAmounts));
+  console.log({
+    totalAmount,
+    totalToppings,
+    avgToppingsPerWallet,
+    avgToppingAmount
+  });
+};
+main().catch(e => console.log(e));

package/scripts/upgradeToV2/upgradeToV2.ts

@@ -88,8 +88,8 @@ export const main = async (
     };
   }
 
-  const isBackendTest = networkName.startsWith("dapptest");
-  const isTest = network.name === "hardhat" || isBackendTest;
+  const isDappTest = networkName.startsWith("dapptest");
+  const isTest = network.name === "hardhat" || isDappTest;
   const isCoverage = process.env.CODE_COVERAGE;
   const isDevelop = !isProduction;
   const isMainnet = networkName.includes("mainnet");
@@ -99,7 +99,7 @@ export const main = async (
   };
   console.log(`networkName ${networkName}`, {
     isTest,
-    isBackendTest,
+    isDappTest,
     isCoverage,
     isMainnet,
     isDevelop
@@ -843,14 +843,30 @@ export const main = async (
     //   Promise.resolve(["0x9999c40c8b88c740076b15d2e708db6a7a071b53", 13888])
     // ];
     let deployed;
-    if (!isRopsten || isTest) {
+    if (!isDappTest && (!isRopsten || isTest)) {
       const aaveps = aaveTokens.map(async token => {
         let rewardsPerBlock = (protocolSettings.staking.rewardsPerBlock / 2) //aave gets half of the rewards
           .toFixed(0);
-        console.log("deployStakingContracts", {
+        console.log("deployStakingContracts aave", {
           token,
           settings: protocolSettings.staking,
-          rewardsPerBlock
+          rewardsPerBlock,
+          params: [
+            token.address,
+            get(protocolSettings, "aave.lendingPool", dao.AaveLendingPool),
+            release.NameService,
+            protocolSettings.staking.fullRewardsThreshold, //blocks before switching for 0.5x rewards to 1x multiplier
+            token.usdOracle,
+
+            get(
+              protocolSettings,
+              "aave.incentiveController",
+              dao.AaveIncentiveController
+            ),
+            token.aaveUsdOracle,
+            token.swapPath,
+            GAS_SETTINGS
+          ]
         });
         const tx = await (
           await aavefactory[
@@ -861,7 +877,6 @@ export const main = async (
             release.NameService,
             protocolSettings.staking.fullRewardsThreshold, //blocks before switching for 0.5x rewards to 1x multiplier
             token.usdOracle,
-
             get(
               protocolSettings,
               "aave.incentiveController",

package/test/FuseFaucet.test.ts

@@ -0,0 +1,168 @@
+import hre, { ethers, upgrades } from "hardhat";
+import { expect } from "chai";
+import { FuseFaucet, IGoodDollar, IIdentity } from "../types";
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
+import { createDAO } from "./helpers";
+
+const BN = ethers.BigNumber;
+
+describe("FuseFaucet", () => {
+  let faucet: FuseFaucet, founder: SignerWithAddress;
+  let user1 = ethers.Wallet.createRandom().connect(ethers.provider);
+  let user2 = ethers.Wallet.createRandom().connect(ethers.provider);
+  let signers;
+
+  let avatar, gd: IGoodDollar, Controller, id: IIdentity;
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+
+    const FuseFaucetF = await ethers.getContractFactory("FuseFaucet");
+
+    let {
+      daoCreator,
+      controller,
+      avatar: av,
+      gd: gooddollar,
+      identity
+    } = await createDAO();
+
+    Controller = controller;
+    avatar = av;
+
+    // await daoCreator.setSchemes(
+    //   avatar,
+    //   [identity],
+    //   [ethers.constants.HashZero],
+    //   ["0x0000001F"],
+    //   ""
+    // );
+
+    faucet = (await upgrades.deployProxy(FuseFaucetF, [identity], {
+      kind: "transparent"
+    })) as FuseFaucet;
+
+    gd = (await ethers.getContractAt(
+      "IGoodDollar",
+      gooddollar,
+      founder
+    )) as IGoodDollar;
+    id = (await ethers.getContractAt(
+      "IIdentity",
+      identity,
+      founder
+    )) as IIdentity;
+
+    await founder.sendTransaction({
+      value: ethers.utils.parseEther("1"),
+      to: faucet.address
+    });
+  });
+
+  it("should have balance", async () => {
+    const balance = await ethers.provider.getBalance(faucet.address);
+    expect(balance).to.equal(ethers.utils.parseEther("1"));
+  });
+
+  it("should let new user top once", async () => {
+    expect(await faucet.canTop(user1.address)).to.true;
+    const tx = await (await faucet.topWallet(user1.address)).wait();
+    const balance = await ethers.provider.getBalance(user1.address);
+    expect(balance).to.equal(await faucet.toppingAmount());
+  });
+
+  it("should not let new user top more than once", async () => {
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.utils.parseUnits("400000", "gwei")
+    });
+    expect(await faucet.canTop(user1.address)).to.false;
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      "User not whitelisted or not first time"
+    );
+  });
+
+  it("should not refund gas when reverted", async () => {
+    const balance = await ethers.provider.getBalance(founder.address);
+    const faucetBalance = await ethers.provider.getBalance(faucet.address);
+    expect(await faucet.canTop(user1.address)).to.false;
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      "User not whitelisted or not first time"
+    );
+    const balanceAfter = await ethers.provider.getBalance(founder.address);
+    const faucetBalanceAfter = await ethers.provider.getBalance(faucet.address);
+    expect(faucetBalanceAfter).to.eq(faucetBalance);
+    expect(balanceAfter).to.lt(balance);
+  });
+
+  it("should let user top again once identified", async () => {
+    await id.addWhitelistedWithDID(user1.address, "did:1");
+    expect(await faucet.canTop(user1.address)).to.true;
+    const tx = await (await faucet.topWallet(user1.address)).wait();
+    console.log(tx.gasUsed.toString());
+    const balance = await ethers.provider.getBalance(user1.address);
+    expect(balance).to.equal(await faucet.toppingAmount());
+  });
+
+  it("should not let identified user top over daily limit", async () => {
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.utils.parseUnits("400000", "gwei")
+    });
+    const tx = await (await faucet.topWallet(user1.address)).wait();
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.utils.parseUnits("400000", "gwei")
+    });
+    expect(await faucet.canTop(user1.address)).to.false;
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      "max daily toppings"
+    );
+  });
+
+  // it("should not top if wallet not half empty", async () => {
+  //   expect(await faucet.canTop(founder.address)).to.false;
+  //   await expect(faucet.topWallet(founder.address)).to.revertedWith(
+  //     "User balance above minimum"
+  //   );
+  // });
+
+  it("should not let user top over weekly limit", async () => {
+    for (let i = 0; i < 3; 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")
+      });
+      // 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"
+    );
+  });
+
+  it("should reimburse gas costs", async () => {
+    const balance = await ethers.provider.getBalance(founder.address);
+    const tx = await (
+      await faucet.topWallet(user2.address, { gasPrice: 1e9 })
+    ).wait();
+    // const gasCosts = tx.gasUsed.mul(1e9);
+    // const afterRefund = gasCosts.sub(await faucet["gasRefund()"]());
+    const balanceAfter = await ethers.provider.getBalance(founder.address);
+    const diff = balance.sub(balanceAfter).toNumber();
+    expect(diff).to.lt(10000);
+  });
+});

package/test/InvitesV1.test.ts

@@ -0,0 +1,354 @@
+import hre, { ethers, upgrades } from "hardhat";
+import { expect } from "chai";
+import { InvitesV1, IGoodDollar, IIdentity } from "../types";
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
+import { createDAO } from "./helpers";
+
+const BN = ethers.BigNumber;
+
+describe("InvitesV1", () => {
+  let invites: InvitesV1, founder: SignerWithAddress;
+  let inviter1,
+    inviter2,
+    invitee1,
+    invitee2,
+    invitee3,
+    invitee4,
+    invitee5,
+    invitee6,
+    invitee7,
+    invitee8;
+
+  let avatar, gd: IGoodDollar, Controller, id: IIdentity;
+
+  before(async () => {
+    [
+      founder,
+      inviter1,
+      inviter2,
+      invitee1,
+      invitee2,
+      invitee3,
+      invitee4,
+      invitee5,
+      invitee6,
+      invitee7,
+      invitee8
+    ] = await ethers.getSigners();
+
+    const InvitesV1 = await ethers.getContractFactory("InvitesV1");
+
+    let {
+      daoCreator,
+      controller,
+      avatar: av,
+      gd: gooddollar,
+      identity
+    } = await createDAO();
+
+    Controller = controller;
+    avatar = av;
+
+    invites = (await upgrades.deployProxy(
+      InvitesV1,
+      [avatar, identity, gooddollar, 500],
+      {
+        unsafeAllowCustomTypes: true,
+        kind: "transparent"
+      }
+    )) as InvitesV1;
+
+    gd = (await ethers.getContractAt(
+      "IGoodDollar",
+      gooddollar,
+      founder
+    )) as IGoodDollar;
+    id = (await ethers.getContractAt(
+      "IIdentity",
+      identity,
+      founder
+    )) as IIdentity;
+
+    await gd["mint(address,uint256)"](invites.address, BN.from(5000));
+    // await gd.transfer(invites.address, BN.from(5000));
+  });
+
+  it("should have balance", async () => {
+    const balance = await gd.balanceOf(invites.address);
+    expect(balance).to.equal(5000);
+  });
+
+  it("should have version", async () => {
+    expect(await invites.active()).to.be.true;
+    const version = await invites.version();
+    expect(version).to.be.equal("1.5.0");
+  });
+
+  it("should let anyone join", async () => {
+    await invites
+      .connect(inviter1)
+      .join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+    let inviter = await invites.users(inviter1.address);
+    expect(inviter.inviteCode).to.equal(ethers.utils.hexZeroPad("0xfa", 32));
+  });
+
+  it("should allow to join only once", async () => {
+    await expect(
+      invites
+        .connect(inviter1)
+        .join(
+          ethers.utils.hexZeroPad("0xfa", 32),
+          ethers.utils.hexZeroPad("0x01", 32)
+        )
+    ).to.revertedWith("user already joined");
+  });
+
+  it("should not allow code reuse", async () => {
+    // const invites = await Invites.deployed();
+    await expect(
+      invites
+        .connect(inviter2)
+        .join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero)
+    ).to.revertedWith("invite code already in use");
+  });
+
+  it("should mark inviter", async () => {
+    await invites
+      .connect(invitee1)
+      .join(
+        ethers.utils.hexZeroPad("0xaa", 32),
+        ethers.utils.hexZeroPad("0xfa", 32)
+      );
+    let invitee = await invites.users(invitee1.address);
+    let inviterInvitees = await invites.getInvitees(inviter1.address);
+    expect(invitee.invitedBy).to.be.equal(inviter1.address);
+    expect(inviterInvitees).to.include(invitee1.address);
+  });
+
+  it("should not pay bounty for non whitelisted invitee", async () => {
+    await expect(
+      invites.connect(inviter1).bountyFor(invitee1.address)
+    ).to.revertedWith("user not elligble for bounty yet");
+  });
+
+  it("should not pay bounty for non whitelisted inviter", async () => {
+    await id.addWhitelistedWithDID(invitee1.address, Math.random() + "");
+    expect(await id.isWhitelisted(invitee1.address)).to.be.true;
+    expect(await invites.canCollectBountyFor(invitee1.address)).to.be.false;
+    await expect(
+      invites.connect(inviter1).bountyFor(invitee1.address)
+    ).to.revertedWith("user not elligble for bounty yet");
+  });
+
+  it("should pay bounty for whitelisted invitee and inviter", async () => {
+    const bounty = (await invites.levels(0)).bounty.toNumber();
+    await id
+      .addWhitelistedWithDID(inviter1.address, Math.random() + "")
+      .catch(e => e);
+    const startBalance = await gd
+      .balanceOf(inviter1.address)
+      .then(_ => _.toNumber());
+    expect(await id.isWhitelisted(inviter1.address)).to.be.true;
+    let pending = await invites.getPendingInvitees(inviter1.address);
+    expect(pending.length, "pending").to.be.equal(1);
+    const inviteeBalance = await gd
+      .balanceOf(invitee1.address)
+      .then(_ => _.toNumber());
+    await invites.connect(inviter1).bountyFor(invitee1.address);
+
+    let invitee = await invites.users(invitee1.address);
+    let inviter = await invites.users(inviter1.address);
+    const endBalance = await gd
+      .balanceOf(inviter1.address)
+      .then(_ => _.toNumber());
+
+    pending = await invites.getPendingInvitees(inviter1.address);
+    const txFee = await gd.getFees(bounty).then(_ => _["0"].toNumber()); //gd might have a tx fee
+    const txFee2 = await gd.getFees(bounty / 2).then(_ => _["0"].toNumber()); //gd might have a tx fee
+
+    expect(pending.length, "pending").to.be.equal(0);
+    expect(invitee.bountyPaid).to.be.true;
+    expect(inviter.totalApprovedInvites.toNumber()).to.be.equal(1);
+    expect(inviter.totalEarned.toNumber()).to.be.equal(bounty);
+    expect(
+      endBalance - startBalance + txFee,
+      "inviter rewards not matching bounty"
+    ).to.be.equal(bounty);
+    expect(
+      (await gd.balanceOf(invitee1.address).then(_ => _.toNumber())) -
+        inviteeBalance,
+      "invitee rewrad should be bounty/2"
+    ).to.be.equal(bounty / 2 - txFee2); //test that invitee  got half bonus
+  });
+
+  it("should update global stats", async () => {
+    const bounty = (await invites.levels(0)).bounty.toNumber();
+    const stats = await invites.stats();
+    expect(stats.totalApprovedInvites.toNumber()).to.be.equal(
+      1,
+      "approved invites"
+    );
+    expect(stats.totalInvited.toNumber()).to.be.equal(1, "total  invited");
+    expect(stats.totalBountiesPaid.toNumber()).to.be.equal(bounty);
+  });
+
+  it("should not pay bounty twice", async () => {
+    await expect(
+      invites.connect(inviter2).bountyFor(invitee1.address)
+    ).to.revertedWith("user not elligble for bounty yet");
+  });
+
+  it("should not fail in collectBounties for invalid invitees", async () => {
+    await invites
+      .connect(invitee7)
+      .join(
+        ethers.utils.hexZeroPad("0x01", 32),
+        ethers.utils.hexZeroPad("0xfa", 32)
+      );
+    await invites
+      .connect(invitee8)
+      .join(
+        ethers.utils.hexZeroPad("0x02", 32),
+        ethers.utils.hexZeroPad("0xfa", 32)
+      );
+
+    let pending = await invites.getPendingInvitees(inviter1.address);
+    expect(pending.length, "pending").to.be.equal(2);
+    await expect(invites.connect(inviter1).collectBounties()).to.not.reverted;
+    let user1 = await invites.users(invitee7.address);
+    let user2 = await invites.users(invitee8.address);
+    pending = await invites.getPendingInvitees(inviter1.address);
+    expect(
+      await invites.getPendingBounties(inviter1.address).then(_ => _.toNumber())
+    ).to.be.equal(0);
+    expect(user1.bountyPaid).to.be.false;
+    expect(user2.bountyPaid).to.be.false;
+    expect(pending.length, "pending").to.be.equal(2);
+  });
+
+  it("should collectBounties for inviter", async () => {
+    await id
+      .addWhitelistedWithDID(invitee7.address, Math.random() + "")
+      .catch(e => e);
+    await id
+      .addWhitelistedWithDID(invitee8.address, Math.random() + "")
+      .catch(e => e);
+    expect(
+      await invites.getPendingBounties(inviter1.address).then(_ => _.toNumber())
+    ).to.be.equal(2);
+    const res = await invites
+      .connect(inviter1)
+      .collectBounties()
+      .catch(e => e);
+
+    let user1 = await invites.users(invitee7.address);
+    let user2 = await invites.users(invitee8.address);
+    let pending = await invites.getPendingInvitees(inviter1.address);
+    expect(
+      await invites.getPendingBounties(inviter1.address).then(_ => _.toNumber())
+    ).to.be.equal(0);
+    expect(pending.length, "pending").to.be.equal(0);
+    expect(user1.bountyPaid, "user1").to.be.true;
+    expect(user2.bountyPaid, "user2").to.be.true;
+  });
+
+  it("should not set level not by owner", async () => {
+    await expect(
+      invites.connect(inviter1).setLevel(0, 1, 5, 1)
+    ).to.revertedWith("Only owner or avatar can perform this action");
+  });
+
+  it("should set level by owner", async () => {
+    await invites.setLevel(0, 1, 5, 1);
+    let lvl = await invites.levels(0);
+    expect(lvl.toNext.toNumber()).to.be.equal(1);
+    expect(lvl.daysToComplete.toNumber()).to.be.equal(1);
+    await invites.setLevel(1, 0, 10, 2);
+    lvl = await invites.levels(1);
+    expect(lvl.toNext.toNumber()).to.be.equal(0);
+    expect(lvl.daysToComplete.toNumber()).to.be.equal(2);
+    expect(lvl.bounty.toNumber()).to.be.equal(10);
+  });
+
+  it("should update inviter level", async () => {
+    await invites
+      .connect(inviter1)
+      .join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero)
+      .then(_ => _.wait())
+      .catch(e => e);
+
+    await id
+      .addWhitelistedWithDID(inviter1.address, Math.random() + "")
+      .catch(e => e);
+    await invites.setLevel(0, 1, 5, 1); //1 inviter to level up
+    await invites.setLevel(1, 0, 10, 2); // 10 bounty for second level
+
+    await invites
+      .connect(invitee4)
+      .join(
+        ethers.utils.hexZeroPad("0x03", 32),
+        ethers.utils.hexZeroPad("0xfa", 32)
+      );
+    await invites
+      .connect(invitee5)
+      .join(
+        ethers.utils.hexZeroPad("0x04", 32),
+        ethers.utils.hexZeroPad("0xfa", 32)
+      );
+    await id
+      .addWhitelistedWithDID(invitee4.address, Math.random() + "")
+      .catch(e => e);
+    await id
+      .addWhitelistedWithDID(invitee5.address, Math.random() + "")
+      .catch(e => e);
+    const res1 = await (await invites.bountyFor(invitee4.address)).wait();
+
+    const log1 = res1.events.find(_ => _.event === "InviterBounty");
+    expect(log1.event).to.be.equal("InviterBounty");
+    expect(log1.args.inviterLevel.toNumber()).to.be.equal(1);
+    expect(log1.args.earnedLevel).to.be.equal(true);
+    expect(log1.args.bountyPaid.toNumber()).to.be.equal(5);
+
+    let inviter = await invites.users(inviter1.address);
+    expect(inviter.level.toNumber()).to.be.equal(1);
+    const res2 = await (
+      await invites.connect(inviter1).collectBounties()
+    ).wait();
+    const log2 = res2.events.find(_ => _.event === "InviterBounty");
+    expect(log2.event).to.be.equal("InviterBounty");
+    expect(log2.args.inviterLevel.toNumber()).to.be.equal(1);
+    expect(log2.args.earnedLevel).to.be.equal(false);
+    expect(log2.args.bountyPaid.toNumber()).to.be.equal(10);
+  });
+
+  it("should allow to set inviter later and pay bounty", async () => {
+    await invites
+      .connect(invitee6)
+      .join(ethers.utils.hexZeroPad("0xfd", 32), ethers.constants.HashZero);
+    await invites
+      .connect(invitee6)
+      .join(
+        ethers.utils.hexZeroPad("0xfd", 32),
+        ethers.utils.hexZeroPad("0xfa", 32)
+      );
+    const invitee = await invites.users(invitee6.address);
+    expect(invitee.invitedBy).to.equal(inviter1.address);
+    await id
+      .addWhitelistedWithDID(invitee6.address, Math.random() + "")
+      .catch(e => e);
+    await expect(invites.bountyFor(invitee6.address)).to.emit(
+      invites,
+      "InviterBounty"
+    );
+  });
+
+  it("should end contract by owner", async () => {
+    expect(
+      await gd.balanceOf(invites.address).then(_ => _.toNumber())
+    ).to.be.gt(0);
+    await invites.end();
+    expect(
+      await gd.balanceOf(invites.address).then(_ => _.toNumber())
+    ).to.be.eq(0);
+  });
+});