@gooddollar/goodprotocol 1.0.23 → 1.0.26-beta.0

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);
+  });
+});

package/test/staking/FuseStaking.test.ts

@@ -0,0 +1,152 @@
+import { ethers, network as networkConfig } from "hardhat";
+import { FuseStakingV3 } from "../../types";
+import { expect } from "chai";
+import { deployMockContract, MockContract } from "ethereum-waffle";
+import hre from "hardhat";
+import { abi as ubiabi } from "../../artifacts/contracts/ubi/UBIScheme.sol/UBIScheme.json";
+import { BigNumber } from "ethers";
+export const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
+
+describe("FuseStakingV3", () => {
+  let staking: FuseStakingV3;
+  let founder, staker1, staker2;
+  let signers;
+
+  let uniswap: MockContract,
+    uniswapFactory,
+    uniswapPair,
+    gdusdcPair,
+    fusefusdPair,
+    ubiMock;
+
+  const deployMocks = async () => {
+    let u = await hre.artifacts.readArtifact("Uniswap");
+    let uf = await hre.artifacts.readArtifact("UniswapFactory");
+    let up = await hre.artifacts.readArtifact("UniswapPair");
+    uniswap = await deployMockContract(signers[0], u.abi);
+    uniswapFactory = await deployMockContract(signers[0], uf.abi);
+    uniswapPair = await deployMockContract(signers[0], up.abi);
+
+    gdusdcPair = await deployMockContract(signers[0], up.abi);
+    fusefusdPair = await deployMockContract(signers[0], up.abi);
+
+    ubiMock = await deployMockContract(signers[0], ubiabi);
+    await uniswap.mock.factory.returns(uniswapFactory.address);
+    await uniswap.mock.WETH.returns(signers[3].address);
+    await uniswapFactory.mock.getPair.returns(uniswapPair.address);
+    await uniswapFactory.mock.getPair
+      .withArgs(
+        ethers.constants.AddressZero,
+        "0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5"
+      )
+      .returns(gdusdcPair.address);
+
+    await uniswapFactory.mock.getPair
+      .withArgs(
+        signers[3].address,
+        "0x249BE57637D8B013Ad64785404b24aeBaE9B098B"
+      )
+      .returns(fusefusdPair.address);
+
+    await uniswapPair.mock.getReserves.returns(
+      ethers.utils.parseEther("1000"),
+      "100000",
+      "0"
+    );
+    await gdusdcPair.mock.getReserves.returns("4984886100", "10789000000", "0");
+    await fusefusdPair.mock.getReserves.returns(
+      ethers.utils.parseEther("10000"),
+      ethers.utils.parseEther("2000"), //200$ fusd 18 decimals
+      "0"
+    );
+  };
+
+  before(async () => {
+    signers = await ethers.getSigners();
+    [founder, staker1, staker2] = signers.map(_ => _.address);
+    await deployMocks();
+
+    let network = networkConfig.name;
+    staking = (await (
+      await ethers.getContractFactory("FuseStakingV3")
+    ).deploy()) as FuseStakingV3;
+
+    await staking.initialize();
+    await staking.upgrade0();
+    await staking.upgrade1(NULL_ADDRESS, ubiMock.address, uniswap.address);
+    await staking.upgrade2();
+  });
+
+  it("should have owner", async () => {
+    expect(await staking.owner()).to.be.equal(founder);
+  });
+
+  it("should calc quantity with slippage", async () => {
+    const res = await staking[
+      "calcMaxTokenWithPriceImpact(uint256,uint256,uint256)"
+    ]("6917100025787759640000", "265724494", ethers.utils.parseEther("500"));
+
+    // const fuseQuantity = ethers.utils.formatEther(res);
+    expect(res.maxToken).to.gt(0);
+    expect(res.maxToken).to.equal(
+      BigNumber.from("6917100025787759640000").mul(3).div(100)
+    );
+    expect(res.tokenOut).to.equal(7717004);
+  });
+
+  it("should calc quantity with uniswap mock", async () => {
+    const res = await staking["calcMaxFuseWithPriceImpact(uint256)"](
+      ethers.utils.parseEther("500")
+    );
+
+    // const fuseQuantity = ethers.utils.formatEther(res);
+    expect(res.fuseAmount).to.gt(0);
+    expect(res.fuseAmount).to.equal(ethers.utils.parseEther("30"));
+
+    await uniswapPair.mock.getReserves.returns(
+      ethers.utils.parseEther("100"),
+      "500000",
+      "0"
+    );
+    const res2 = await staking["calcMaxFuseWithPriceImpact(uint256)"](
+      ethers.utils.parseEther("500")
+    );
+
+    expect(res2.fuseAmount).to.equal(ethers.utils.parseEther("3"));
+  });
+
+  it("should calculate gd/usdc quantity with 0 price impact ", async () => {
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
+      ethers.utils.parseEther("10")
+    );
+    //exchanging 10 fuse which are equal 2$ USDC should have no significant price impact on usdc/gd swap so we should be able to swap the whole 10
+    expect(res.maxFuse).to.gt(0);
+    expect(res.maxFuse).to.equal(ethers.utils.parseEther("10"));
+  });
+
+  it("should detect gd/usdc price impact", async () => {
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
+      ethers.utils.parseEther("10000")
+    );
+    expect(res.maxFuse).to.lt(ethers.utils.parseEther("10000"));
+    expect(res.maxFuse).to.equal(ethers.utils.parseEther("1618.35")); //on fuse swap it was around 335$ on above gd/usdc reserves that reaches 3% impact, that means 335*5=1675fuse
+  });
+
+  it("should match fuseswap and allow to exchange +-4600 fuse to G$", async () => {
+    //G$/usdc reserves 52,841,23400/10410000000
+    //fuse/fusd reserves 619085*1e18/42905*1e18
+
+    await gdusdcPair.mock.getReserves.returns("5284123400", "10410000000", "0");
+    await fusefusdPair.mock.getReserves.returns(
+      ethers.utils.parseEther("619085"),
+      ethers.utils.parseEther("42905"),
+      "0"
+    );
+
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
+      ethers.utils.parseEther("10000")
+    );
+    expect(res.maxFuse).to.lt(ethers.utils.parseEther("5000"));
+    expect(res.maxFuse).to.gt(ethers.utils.parseEther("4500"));
+  });
+});