@gooddollar/goodprotocol 2.0.25-beta.1 → 2.0.25-beta.3

package/test/invite/InvitesV2.test.ts

@@ -11,39 +11,14 @@ const BN = ethers.BigNumber;
 
 describe("InvitesV2", () => {
   let invites: InvitesV2, founder: SignerWithAddress;
-  let inviter1,
-    inviter2,
-    invitee1,
-    invitee2,
-    invitee3,
-    invitee4,
-    invitee5,
-    invitee6,
-    invitee7,
-    invitee8;
-
-  let avatar,
-    gd: IGoodDollar,
-    Controller,
-    id: IdentityV2,
-    setDAOAddress,
-    setSchemes;
+  let inviter1, inviter2, invitee1, invitee2, invitee3, invitee4, invitee5, invitee6, invitee7, invitee8;
+
+  let avatar, gd: IGoodDollar, Controller, id: IdentityV2, setDAOAddress, setSchemes;
 
   const initialState = async () => {};
   before(async () => {
-    [
-      founder,
-      inviter1,
-      inviter2,
-      invitee1,
-      invitee2,
-      invitee3,
-      invitee4,
-      invitee5,
-      invitee6,
-      invitee7,
-      invitee8
-    ] = await ethers.getSigners();
+    [founder, inviter1, inviter2, invitee1, invitee2, invitee3, invitee4, invitee5, invitee6, invitee7, invitee8] =
+      await ethers.getSigners();
 
     const InvitesV2 = await ethers.getContractFactory("InvitesV2");
 
@@ -62,24 +37,12 @@ describe("InvitesV2", () => {
     setDAOAddress = sda;
     setSchemes = sc;
 
-    invites = (await upgrades.deployProxy(
-      InvitesV2,
-      [nameService.address, 500, founder.address],
-      {
-        kind: "uups"
-      }
-    )) as InvitesV2;
-
-    gd = (await ethers.getContractAt(
-      "IGoodDollar",
-      gooddollar,
-      founder
-    )) as IGoodDollar;
-    id = (await ethers.getContractAt(
-      "IdentityV2",
-      identity,
-      founder
-    )) as IdentityV2;
+    invites = (await upgrades.deployProxy(InvitesV2, [nameService.address, 500, founder.address], {
+      kind: "uups"
+    })) as InvitesV2;
+
+    gd = (await ethers.getContractAt("IGoodDollar", gooddollar, founder)) as IGoodDollar;
+    id = (await ethers.getContractAt("IdentityV2", identity, founder)) as IdentityV2;
 
     await gd["mint(address,uint256)"](invites.address, BN.from(5000));
     await loadFixture(initialState);
@@ -88,21 +51,13 @@ describe("InvitesV2", () => {
 
   it("v1 should be upgradeable via old proxy method", async () => {
     const InvitesV1 = await ethers.getContractFactory("InvitesV1");
-    const invites = await upgrades.deployProxy(
-      InvitesV1,
-      [avatar, id.address, gd.address, 500],
-      {
-        kind: "transparent"
-      }
-    );
-    const res = await upgrades.upgradeProxy(
-      invites.address,
-      await ethers.getContractFactory("InvitesFuseV2"),
-      {
-        kind: "transparent",
-        unsafeAllowRenames: true
-      }
-    );
+    const invites = await upgrades.deployProxy(InvitesV1, [avatar, id.address, gd.address, 500], {
+      kind: "transparent"
+    });
+    const res = await upgrades.upgradeProxy(invites.address, await ethers.getContractFactory("InvitesFuseV2"), {
+      kind: "transparent",
+      unsafeAllowRenames: true
+    });
     expect(res).not.empty;
   });
 
@@ -114,44 +69,30 @@ describe("InvitesV2", () => {
   it("should have version", async () => {
     expect(await invites.active()).to.be.true;
     const version = await invites.version();
-    expect(version).to.be.equal("2.2");
+    expect(version).to.be.equal("2.3");
   });
 
   it("should let anyone join", async () => {
-    await invites
-      .connect(inviter1)
-      .join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+    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)
-        )
+      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)
+      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)
-      );
+    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);
@@ -159,9 +100,9 @@ describe("InvitesV2", () => {
   });
 
   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/);
+    await expect(invites.connect(inviter1).bountyFor(invitee1.address)).to.revertedWith(
+      /user not elligble for bounty yet/
+    );
   });
 
   it("should not allow to pay bounty for non whitelisted inviter", async () => {
@@ -175,45 +116,29 @@ describe("InvitesV2", () => {
 
   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());
+    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());
+    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());
+    const endBalance = await gd.balanceOf(inviter1.address).then(_ => _.toNumber());
 
     pending = await invites.getPendingInvitees(inviter1.address);
-    const txFee = await gd["getFees(uint256)"](bounty).then(_ =>
-      _["0"].toNumber()
-    ); //gd might have a tx fee
-    const txFee2 = await gd["getFees(uint256)"](bounty / 2).then(_ =>
-      _["0"].toNumber()
-    ); //gd might have a tx fee
+    const txFee = await gd["getFees(uint256)"](bounty).then(_ => _["0"].toNumber()); //gd might have a tx fee
+    const txFee2 = await gd["getFees(uint256)"](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(
-      endBalance - startBalance + txFee,
-      "inviter rewards not matching bounty"
-    ).to.be.equal(bounty);
-    expect(
-      (await gd.balanceOf(invitee1.address).then(_ => _.toNumber())) -
-        inviteeBalance,
+      (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
   });
@@ -221,33 +146,20 @@ describe("InvitesV2", () => {
   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.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/);
+    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)
-      );
+    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);
@@ -255,9 +167,7 @@ describe("InvitesV2", () => {
     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(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);
@@ -266,26 +176,22 @@ describe("InvitesV2", () => {
   it("should collectBounties for inviter", async () => {
     await id.addWhitelistedWithDID(invitee7.address, Math.random() + "");
     await id.addWhitelistedWithDID(invitee8.address, Math.random() + "");
-    expect(
-      await invites.getPendingBounties(inviter1.address).then(_ => _.toNumber())
-    ).to.be.equal(2);
+    expect(await invites.getPendingBounties(inviter1.address).then(_ => _.toNumber())).to.be.equal(2);
     const res = await invites.connect(inviter1).collectBounties();
 
     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(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/);
+    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 () => {
@@ -307,30 +213,14 @@ describe("InvitesV2", () => {
       .then(_ => _.wait())
       .catch(e => e);
 
-    await id
-      .addWhitelistedWithDID(inviter1.address, Math.random() + "")
-      .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);
+    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");
@@ -341,9 +231,7 @@ describe("InvitesV2", () => {
 
     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 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);
@@ -352,50 +240,27 @@ describe("InvitesV2", () => {
   });
 
   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)
-      );
+    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"
-    );
+    await id.addWhitelistedWithDID(invitee6.address, Math.random() + "").catch(e => e);
+    await expect(invites.bountyFor(invitee6.address)).to.emit(invites, "InviterBounty");
   });
 
   describe("MultiChain", () => {
     it("should not revert if old identity contract without getWhitelistedOnChain", async () => {
       await loadFixture(initialState);
-      const contractFactory = new ethers.ContractFactory(
-        IdentityABI.abi,
-        IdentityABI.bytecode,
-        founder
-      );
+      const contractFactory = new ethers.ContractFactory(IdentityABI.abi, IdentityABI.bytecode, founder);
       const oldId = await contractFactory.deploy();
       await oldId.setAvatar(avatar);
       await setSchemes([oldId.address], []);
       await setDAOAddress("IDENTITY", oldId.address);
 
       expect(await invites.getIdentity()).equal(oldId.address);
-      await invites
-        .connect(inviter1)
-        .join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
 
-      await invites
-        .connect(invitee2)
-        .join(
-          ethers.utils.hexZeroPad("0xaa", 32),
-          ethers.utils.hexZeroPad("0xfa", 32)
-        );
+      await invites.connect(invitee2).join(ethers.utils.hexZeroPad("0xaa", 32), ethers.utils.hexZeroPad("0xfa", 32));
 
       await oldId.addWhitelistedWithDID(invitee2.address, Math.random() + "");
       await oldId.addWhitelistedWithDID(inviter1.address, Math.random() + "");
@@ -405,115 +270,118 @@ describe("InvitesV2", () => {
     it("should always be able to use my address as invite code", async () => {
       await loadFixture(initialState);
 
-      await invites
-        .connect(inviter1)
-        .join(
-          ethers.utils.hexZeroPad(inviter1.address, 32),
-          ethers.constants.HashZero
-        );
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad(inviter1.address, 32), ethers.constants.HashZero);
 
       await expect(
-        invites
-          .connect(inviter2)
-          .join(
-            ethers.utils.hexZeroPad(inviter2.address, 32),
-            ethers.constants.HashZero
-          )
+        invites.connect(inviter2).join(ethers.utils.hexZeroPad(inviter2.address, 32), ethers.constants.HashZero)
       ).not.reverted;
 
       await expect(
-        invites
-          .connect(inviter1)
-          .join(
-            ethers.utils.hexZeroPad(inviter1.address, 32),
-            ethers.constants.HashZero
-          )
+        invites.connect(inviter1).join(ethers.utils.hexZeroPad(inviter1.address, 32), ethers.constants.HashZero)
       ).reverted;
     });
 
     it("should not allow to claim if whitelisted originally on another chain", async () => {
       await loadFixture(initialState);
-      await invites
-        .connect(inviter1)
-        .join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
-      await invites
-        .connect(invitee2)
-        .join(
-          ethers.utils.hexZeroPad("0xaa", 32),
-          ethers.utils.hexZeroPad("0xfa", 32)
-        );
-
-      await id.addWhitelistedWithDIDAndChain(
-        invitee2.address,
-        Math.random() + "",
-        122,
-        0
-      );
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+      await invites.connect(invitee2).join(ethers.utils.hexZeroPad("0xaa", 32), ethers.utils.hexZeroPad("0xfa", 32));
+
+      await id.addWhitelistedWithDIDAndChain(invitee2.address, Math.random() + "", 122, 0);
       expect(await id.getWhitelistedOnChainId(invitee2.address)).equal(122);
-      await expect(
-        invites.connect(inviter1).bountyFor(invitee2.address)
-      ).to.revertedWith(/user not elligble for bounty yet/);
+      await expect(invites.connect(inviter1).bountyFor(invitee2.address)).to.revertedWith(
+        /user not elligble for bounty yet/
+      );
     });
 
     it("should allow to claim if whitelisted originally on same chain", async () => {
       await loadFixture(initialState);
-      await invites
-        .connect(inviter1)
-        .join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
-      await invites
-        .connect(invitee2)
-        .join(
-          ethers.utils.hexZeroPad("0xaa", 32),
-          ethers.utils.hexZeroPad("0xfa", 32)
-        );
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad("0xfa", 32), ethers.constants.HashZero);
+      await invites.connect(invitee2).join(ethers.utils.hexZeroPad("0xaa", 32), ethers.utils.hexZeroPad("0xfa", 32));
 
       await id.addWhitelistedWithDID(inviter1.address, Math.random() + "");
 
-      await id.addWhitelistedWithDIDAndChain(
-        invitee2.address,
-        Math.random() + "",
-        4447,
-        0
-      );
+      await id.addWhitelistedWithDIDAndChain(invitee2.address, Math.random() + "", 4447, 0);
       expect(await id.getWhitelistedOnChainId(invitee2.address)).equal(4447);
-      await expect(invites.connect(inviter1).bountyFor(invitee2.address)).not
-        .reverted;
+      await expect(invites.connect(inviter1).bountyFor(invitee2.address)).not.reverted;
     });
 
     it("should pay bounty on join for whitelisted invitee and inviter", async () => {
       await loadFixture(initialState);
-      await id
-        .addWhitelistedWithDID(inviter1.address, Math.random() + "")
-        .catch(e => e);
-      await id
-        .addWhitelistedWithDID(invitee1.address, Math.random() + "")
-        .catch(e => e);
-
-      await invites
-        .connect(inviter1)
-        .join(
-          ethers.utils.hexZeroPad(inviter1.address, 32),
-          ethers.constants.HashZero
-        );
+      await id.addWhitelistedWithDID(inviter1.address, Math.random() + "").catch(e => e);
+      await id.addWhitelistedWithDID(invitee1.address, Math.random() + "").catch(e => e);
+
+      await invites.connect(inviter1).join(ethers.utils.hexZeroPad(inviter1.address, 32), ethers.constants.HashZero);
       const tx = await invites
         .connect(invitee1)
-        .join(
-          ethers.utils.hexZeroPad(invitee1.address, 32),
-          ethers.utils.hexZeroPad(inviter1.address, 32)
-        );
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.utils.hexZeroPad(inviter1.address, 32));
       const { events } = await tx.wait();
       const bountyEvent = events.find(_ => _.event === "InviterBounty");
       expect(bountyEvent).not.empty;
     });
   });
 
+  describe("Campaign Code", () => {
+    it("should not pay bounty on empty campaignCode", async () => {
+      await loadFixture(initialState);
+      await id.addWhitelistedWithDID(invitee1.address, Math.random() + "").catch(e => e);
+
+      const tx = await invites
+        .connect(invitee1)
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.constants.HashZero);
+      const { events } = await tx.wait();
+      const bountyEvent = events.find(_ => _.event === "InviterBounty");
+      expect(bountyEvent).undefined;
+    });
+    it("should not pay bounty on wrong campaignCode", async () => {
+      await loadFixture(initialState);
+      await invites.setCampaignCode(ethers.utils.formatBytes32String("test"));
+      await id.addWhitelistedWithDID(invitee1.address, Math.random() + "").catch(e => e);
+
+      const tx = await invites
+        .connect(invitee1)
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.utils.formatBytes32String("test2"));
+      const { events } = await tx.wait();
+      const bountyEvent = events.find(_ => _.event === "InviterBounty");
+      expect(bountyEvent).undefined;
+    });
+
+    it("should pay bounty with campaignCode", async () => {
+      await loadFixture(initialState);
+      await invites.setCampaignCode(ethers.utils.formatBytes32String("test"));
+      await id.addWhitelistedWithDID(invitee1.address, Math.random() + "").catch(e => e);
+
+      const tx = await invites
+        .connect(invitee1)
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.utils.formatBytes32String("test"));
+      const { events } = await tx.wait();
+      const bountyEvent = events.find(_ => _.event === "InviterBounty");
+      expect(bountyEvent).not.empty;
+    });
+
+    it("should pay bounty with campaignCode after first join without code", async () => {
+      await loadFixture(initialState);
+      await invites.setCampaignCode(ethers.utils.formatBytes32String("test"));
+      await id.addWhitelistedWithDID(invitee1.address, Math.random() + "").catch(e => e);
+
+      const tx = await invites
+        .connect(invitee1)
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.constants.HashZero);
+      const { events } = await tx.wait();
+      const bountyEvent = events.find(_ => _.event === "InviterBounty");
+      expect(bountyEvent).undefined;
+
+      const tx2 = await invites
+        .connect(invitee1)
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.utils.formatBytes32String("test"));
+      const { events: events2 } = await tx2.wait();
+      const bountyEvent2 = events2.find(_ => _.event === "InviterBounty");
+      expect(bountyEvent2).not.undefined;
+    });
+  });
+
   it("should end contract by owner", async () => {
-    expect(
-      await gd.balanceOf(invites.address).then(_ => _.toNumber())
-    ).to.be.gt(0);
+    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);
+    expect(await gd.balanceOf(invites.address).then(_ => _.toNumber())).to.be.eq(0);
   });
 });