gn-contract 1.0.0

package/test/rank_distribution.test.ts

@@ -0,0 +1,142 @@
+import { expect } from "chai";
+import { fromBn, toBn } from "evm-bn";
+import { ethers } from "hardhat";
+import { initialize, getState, getAccounts } from "./lib/initializer";
+import { reserveAddress } from "../constants/rootAddress";
+import { BigNumber } from "ethers";
+
+describe("Valhalla Rank Distribution", function () {
+  before(async () => {
+    await initialize();
+  });
+
+  it("parent should become Rank Common", async () => {
+    const { valhalla, usdt } = getState();
+    const accounts = await getAccounts(14, 101);
+    const owner = await getAccounts(0);
+
+    const parent = accounts[0];
+    for (let i = 1; i <= 100; i++) {
+      const tranferErc20 = await usdt
+        .connect(owner[0])
+        .transfer(accounts[i].address, toBn("60", 18));
+      await tranferErc20.wait();
+
+      const userApprove = await usdt
+        .connect(accounts[i])
+        .approve(valhalla.address, await usdt.balanceOf(accounts[i].address));
+      await userApprove.wait();
+
+      const account = accounts[i];
+      const tx = await valhalla.connect(account).register(parent.address);
+      const receipt = await tx.wait();
+      expect(receipt.status).to.eq(1);
+    }
+
+    const parentAccount = await valhalla.accountMap(parent.address);
+    expect(parentAccount.rank).to.eq(1);
+    expect(parentAccount.downlineCount).to.eq(100);
+  });
+
+  it("should bump rank distribution count", async () => {
+    const { valhalla } = getState();
+    const { common } = await valhalla.rankDistribution();
+    expect(common.toString()).to.eq(String(15));
+  });
+
+  it("should have correct ipo pool value", async () => {
+    const { valhalla } = getState();
+    const ipoPool = await valhalla.getIpoPool();
+    expect(ipoPool.claimable).to.eq(0);
+    expect(ipoPool.valueLeft).to.eq(0);
+  });
+
+  it("should have correct global pool value", async () => {
+    const { valhalla } = getState();
+    const globalPoolVal = await valhalla.getGlobalPool();
+    const valPerRegistration = toBn("50", 18).mul(17).div(100);
+    expect(globalPoolVal.claimable).to.eq(valPerRegistration.mul(100));
+  });
+
+  it("should have correct reserved balance", async () => {
+    const { usdt, nftFounder } = getState();
+    const balance = await usdt.balanceOf(nftFounder.address);
+    const valPerRegistration = toBn("50", 18).mul(3).div(100);
+    expect(balance).to.eq(valPerRegistration.mul(100));
+  });
+
+  it("should have correct fee receiver reward", async () => {
+    const { feeReceiver, feeReceiver2, usdt } = getState();
+    const rewardFee1 = await usdt.balanceOf(feeReceiver.address);
+    const rewardFee2 = await usdt.balanceOf(feeReceiver2.address);
+    // new plan fee receiver split with two person
+    const valPerRegistration = toBn("50", 18).mul(25).div(100);
+    expect(rewardFee1).to.eq(valPerRegistration.mul(100).div(2));
+    expect(rewardFee2).to.eq(valPerRegistration.mul(100).div(2));
+  });
+
+  it("make sure able to purchase nft", async () => {
+    const { nft, crowd } = getState();
+    const [admin] = await getAccounts(0);
+    const approveTx = await crowd
+      .connect(admin)
+      .approve(nft.address, toBn("50000", 18));
+    await approveTx.wait();
+    const tx = await nft.connect(admin).buy(1);
+    const receipt = await tx.wait();
+    expect(receipt.status).to.eq(1);
+    const tx1 = await nft.connect(admin).buy(1);
+    const receipt1 = await tx1.wait();
+    expect(receipt1.status).to.eq(1);
+  });
+
+  it("should have correct rank reward", async () => {
+    const { valhalla } = getState();
+    const [admin] = await getAccounts(0);
+    const tx = await valhalla.connect(admin).startClaimingRankReward();
+    await tx.wait();
+    const myReward = await valhalla
+      .connect(admin)
+      .getMyRankReward(admin.address);
+    const globalPool = await valhalla.getGlobalPool();
+    const { common } = await valhalla.rankDistribution();
+    const baseReward = globalPool.valueLeft.mul(3).div(100);
+    const expectedReward = baseReward.div(common);
+    expect(myReward).to.eq(expectedReward);
+  });
+
+  it("should have correct NFT rank reward", async () => {
+    const { nft, valhalla } = getState();
+    const [admin] = await getAccounts(0);
+    const myReward = await nft.getMyRankReward(admin.address);
+    const globalPool = await nft.getGlobalPool();
+    const { common } = await valhalla.rankDistribution();
+    const baseReward = globalPool.valueLeft.mul(3).div(100);
+    const expectedReward = baseReward.div(common);
+    expect(myReward).to.eq(expectedReward);
+  });
+
+  it("should be able to claim rank reward", async () => {
+    const { valhalla } = getState();
+    const [admin] = await getAccounts(0);
+    const myReward = await valhalla
+      .connect(admin)
+      .getMyRankReward(admin.address);
+
+    const { valueLeft: initialValueLeft } = await valhalla.getGlobalPool();
+
+    const tx = await valhalla.connect(admin).claimRankReward();
+    const receipt = await tx.wait();
+    expect(receipt.status).to.eq(1);
+
+    const { valueLeft } = await valhalla.getGlobalPool();
+    expect(valueLeft).to.eq(initialValueLeft.sub(myReward));
+
+    const tx2 = await valhalla.connect(admin).stopClaimingRankReward();
+    await tx2.wait();
+
+    const poolAfterStop = await valhalla.getGlobalPool();
+    expect(poolAfterStop.valueLeft).to.eq(BigNumber.from("0"));
+    expect(poolAfterStop.claimable).to.eq(initialValueLeft.sub(myReward));
+  });
+});

package/test/registration.test.ts

@@ -0,0 +1,267 @@
+import { expect } from "chai";
+import { toBn } from "evm-bn";
+import { ethers } from "hardhat";
+import { initialize, getState, getAccounts } from "./lib/initializer";
+
+describe("Valhalla Registration", function () {
+  before(async () => {
+    await initialize();
+  });
+
+  it("check root addresses", async () => {
+    const { valhalla } = getState();
+    let referrer = "0x0000000000000000000000000000000000000000";
+    const accounts = await getAccounts(0, 15);
+    for (let i = 0; i < 15; i++) {
+      const account = await valhalla.accountMap(accounts[i].address);
+      expect(account.referrer).to.eq(referrer);
+      expect(account.downlineCount).to.eq(15 - i - 1);
+      referrer = accounts[i].address;
+    }
+  });
+
+  it("make sure can register successfully", async () => {
+    const { valhalla, usdt } = getState();
+    const owner = await getAccounts(0);
+    const accounts = await getAccounts(14, 2);
+    const account = accounts[1];
+
+    // before registration user need USDT (20 registration fee)
+    // then user with transferred USDT need to approve their token
+
+    const transferUsdt = await usdt
+      .connect(owner[0])
+      .transfer(account.address, toBn("21", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(account)
+      .approve(valhalla.address, usdt.balanceOf(account.address));
+    await approvalUsdt.wait();
+
+    const tx = await valhalla.connect(account).register(accounts[0].address);
+    const receipt = await tx.wait();
+    expect(receipt.status).to.eq(1);
+  });
+
+  it("make sure can't register if the price are below", async () => {
+    const { valhalla, usdt } = getState();
+    const owner = await getAccounts(0);
+    const accounts = await getAccounts(15, 2);
+    const account = accounts[1];
+
+    const transferUsdt = await usdt
+      .connect(owner[0])
+      .transfer(account.address, toBn("10", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(account)
+      .approve(valhalla.address, usdt.balanceOf(account.address));
+    await approvalUsdt.wait();
+
+    const tx = valhalla.connect(account).register(accounts[0].address);
+    await expect(tx).to.be.revertedWith("Unmatch Registration Fee");
+  });
+
+  it("make sure can't register if the address already registered", async () => {
+    const { valhalla, usdt } = getState();
+    const owner = await getAccounts(0);
+    const accounts = await getAccounts(14, 2);
+    const account = accounts[1];
+
+    const transferUsdt = await usdt
+      .connect(owner[0])
+      .transfer(account.address, toBn("20", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(account)
+      .approve(valhalla.address, usdt.balanceOf(account.address));
+    await approvalUsdt.wait();
+
+    const tx = valhalla.connect(account).register(accounts[0].address);
+    await expect(tx).to.be.revertedWith("Address already registered");
+  });
+
+  it("make sure can't register if the using zero referrer", async () => {
+    const { valhalla, usdt } = getState();
+    const owner = await getAccounts(0);
+    const accounts = await getAccounts(16);
+    const account = accounts[0];
+
+    const transferUsdt = await usdt
+      .connect(owner[0])
+      .transfer(account.address, toBn("20", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(account)
+      .approve(valhalla.address, usdt.balanceOf(account.address));
+    await approvalUsdt.wait();
+
+    const tx = valhalla
+      .connect(account)
+      .register("0x0000000000000000000000000000000000000000");
+    await expect(tx).to.be.revertedWith("Invalid referrer");
+  });
+
+  it("make sure can't register referrer isn't registered", async () => {
+    const { valhalla, usdt } = getState();
+    const owner = await getAccounts(0);
+    const accounts = await getAccounts(16, 4);
+    const account = accounts[0];
+
+    const transferUsdt = await usdt
+      .connect(owner[0])
+      .transfer(account.address, toBn("20", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(account)
+      .approve(valhalla.address, usdt.balanceOf(account.address));
+    await approvalUsdt.wait();
+
+    const tx = valhalla.connect(account).register(accounts[3].address);
+    await expect(tx).to.be.revertedWith("Referrer should be registered");
+  });
+
+  it("owner change, register fee", async () => {
+    const { valhalla } = getState();
+    const accounts = await getAccounts(0, 1);
+    const owner = accounts[0];
+
+    const changeFeeReg = await valhalla
+      .connect(owner)
+      .changeFeeRegister(0, toBn("15", 18));
+
+    const receipts = await changeFeeReg.wait();
+
+    expect(1).to.eq(receipts.status);
+  });
+
+  it("get registration fee", async () => {
+    const { valhalla } = getState();
+    const getRegFee = await valhalla.getRegistrationFee();
+    const expectFee = toBn("15", 18);
+    expect(expectFee).to.eq(getRegFee);
+  });
+
+  it("make sure fee register has been changed", async () => {
+    const { valhalla, usdt } = getState();
+    const _accounts = await getAccounts(0, 15);
+
+    const accounts = await getAccounts(20, 1);
+    const commonUser = accounts[0];
+    const feeRegister = toBn("15", 18);
+
+    const transferUsdt = await usdt
+      .connect(_accounts[0])
+      .transfer(commonUser.address, toBn("15", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(commonUser)
+      .approve(valhalla.address, usdt.balanceOf(commonUser.address));
+    await approvalUsdt.wait();
+
+    const balanceBefore = await usdt.balanceOf(commonUser.address);
+
+    const register = await valhalla
+      .connect(commonUser)
+      .register(_accounts[14].address);
+
+    const receipts = await register.wait();
+    expect(1).to.eq(receipts.status);
+
+    const balanceAfter = await usdt.balanceOf(commonUser.address);
+    const compare = balanceBefore.sub(balanceAfter).gte(feeRegister);
+    expect(true).to.eq(compare);
+  });
+
+  it("make sure can't register if referrer is blacklisted", async () => {
+    const { valhalla, usdt } = getState();
+    const owner = await getAccounts(0);
+    const accounts = await getAccounts(21, 2);
+    const account = accounts[0];
+    const referrerAccount = accounts[1];
+
+    // Register the referrer first
+    const transferToReferrer = await usdt
+      .connect(owner[0])
+      .transfer(referrerAccount.address, toBn("20", 18));
+    await transferToReferrer.wait();
+
+    const approvalReferrer = await usdt
+      .connect(referrerAccount)
+      .approve(valhalla.address, usdt.balanceOf(referrerAccount.address));
+    await approvalReferrer.wait();
+
+    await valhalla.connect(referrerAccount).register(owner[0].address);
+
+    // Blacklist the referrer
+    await valhalla.connect(owner[0]).blackListAddress(referrerAccount.address);
+
+    // Try to register with blacklisted referrer
+    const transferUsdt = await usdt
+      .connect(owner[0])
+      .transfer(account.address, toBn("20", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(account)
+      .approve(valhalla.address, usdt.balanceOf(account.address));
+    await approvalUsdt.wait();
+
+    const tx = valhalla.connect(account).register(referrerAccount.address);
+    await expect(tx).to.be.revertedWith("Referrer blacklisted");
+  });
+
+  it("make sure can't register if registrant is blacklisted", async () => {
+    const { valhalla, usdt } = getState();
+    const owner = await getAccounts(0);
+    const accounts = await getAccounts(22, 2);
+    const account = accounts[0];
+
+    // Blacklist the registrant
+    await valhalla.connect(owner[0]).blackListAddress(account.address);
+
+    // Try to register
+    const transferUsdt = await usdt
+      .connect(owner[0])
+      .transfer(account.address, toBn("20", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(account)
+      .approve(valhalla.address, usdt.balanceOf(account.address));
+    await approvalUsdt.wait();
+
+    const tx = valhalla.connect(account).register(owner[0].address);
+    await expect(tx).to.be.revertedWith("Address blacklisted");
+  });
+
+  it("make sure can't register when registration is closed", async () => {
+    const { valhalla, usdt } = getState();
+    const owner = await getAccounts(0);
+    const accounts = await getAccounts(23, 1);
+    const account = accounts[0];
+
+    // Close registration by starting rank reward claiming
+    await valhalla.connect(owner[0]).startClaimingRankReward();
+
+    // Try to register
+    const transferUsdt = await usdt
+      .connect(owner[0])
+      .transfer(account.address, toBn("20", 18));
+    await transferUsdt.wait();
+
+    const approvalUsdt = await usdt
+      .connect(account)
+      .approve(valhalla.address, usdt.balanceOf(account.address));
+    await approvalUsdt.wait();
+
+    const tx = valhalla.connect(account).register(owner[0].address);
+    await expect(tx).to.be.revertedWith("Registration closed");
+  });
+});

package/test/registration_reward.test.ts

@@ -0,0 +1,114 @@
+import { expect } from "chai";
+import { fromBn, toBn } from "evm-bn";
+import {
+  initialize,
+  getState,
+  getAccounts,
+  setBalance,
+} from "./lib/initializer";
+
+const calculateReward = (
+  refNumber: number,
+  percentage: number,
+  multiplier: number,
+  decimals?: number,
+) => {
+  const rewardPerTransaction = toBn("" + refNumber, decimals ?? 18)
+    .mul(percentage)
+    .div(100);
+  return rewardPerTransaction.mul(multiplier);
+};
+
+describe("Valhalla Registration Reward", function () {
+  before(async () => {
+    await initialize();
+  });
+
+  it("should distribute reward correctly", async () => {
+    const { valhalla, usdt, feeReceiver, feeReceiver2 } = getState();
+    const accounts = await getAccounts(15, 10);
+    const rootAccountList = await getAccounts(0, 15);
+    const usdtDecimal = await usdt.decimals();
+
+    // cleanup the root account balance
+    for (let i = 0; i < rootAccountList.length; i++) {
+      await setBalance(rootAccountList[i].address, 10);
+    }
+
+    const parent = rootAccountList[14];
+    for (let i = 0; i < accounts.length; i++) {
+      // transfer erc20 (USDT) to user
+      const transferERC20 = await usdt
+        .connect(rootAccountList[0])
+        .transfer(accounts[i].address, toBn("100", 18));
+      await transferERC20.wait();
+
+      // users need approve their token
+      const approveToken = await usdt
+        .connect(accounts[i])
+        .approve(valhalla.address, usdt.balanceOf(accounts[i].address));
+      await approveToken.wait();
+
+      const account = accounts[i];
+      const tx = await valhalla.connect(account).register(parent.address);
+      const receipt = await tx.wait();
+      expect(receipt.status).to.eq(1);
+    }
+
+    const calculationv2 = [
+      30, 8, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    ].reverse();
+
+    for (let i = 0; i < rootAccountList.length; i++) {
+      const rewardCalculation = calculateReward(
+        50, // this value depend on refererrer pool distribution
+        calculationv2[i], // this value is list from share point from 1 - 15
+        accounts.length, // this value is list user downline
+        usdtDecimal, // this is decimal currency by default is 18
+      );
+      const rewardReal = await valhalla.rewardMap(rootAccountList[i].address);
+      expect(rewardCalculation).to.eq(rewardReal);
+
+      // reward should decrease by tax at 10%
+      const taxCalculation = rewardCalculation.mul(10).div(100);
+      const taxReal = rewardReal.mul(10).div(100);
+      const halfTax = taxReal.div(2);
+      expect(taxCalculation).to.eq(taxReal);
+
+      // the referre should be get reward sub by tax
+      const rewardGet = rewardCalculation.sub(taxCalculation);
+
+      // before claim check the ERC20 balance
+      const balanceBefore = await usdt.balanceOf(rootAccountList[i].address);
+      const balanceFeeRecieverBefore = await usdt.balanceOf(
+        feeReceiver.address,
+      );
+      const balanceFeeReciever2Before = await usdt.balanceOf(
+        feeReceiver2.address,
+      );
+
+      // claim reward
+      const tx = await valhalla.connect(rootAccountList[i]).claimReward();
+      await tx.wait();
+
+      // check balance after claim
+      const balanceAfter = await usdt.balanceOf(rootAccountList[i].address);
+      const balanceFeeRecieverAfter = await usdt.balanceOf(feeReceiver.address);
+      const balanceFeeReciever2After = await usdt.balanceOf(
+        feeReceiver2.address,
+      );
+      // referrer get
+      const referrerGet = balanceAfter.sub(balanceBefore);
+      expect(rewardGet).to.eq(referrerGet);
+      // fee reciever get
+      const feeReceiverGet = balanceFeeRecieverAfter.sub(
+        balanceFeeRecieverBefore,
+      );
+      const feeReceiver2Get = balanceFeeReciever2After.sub(
+        balanceFeeReciever2Before,
+      );
+      expect(feeReceiverGet).eq(halfTax);
+      expect(feeReceiver2Get).eq(halfTax);
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  }
+}