gn-contract 1.0.0

package/test/nft_genesis.test.ts

@@ -0,0 +1,399 @@
+import { expect } from "chai";
+import { fromBn, toBn } from "evm-bn";
+import { initialize, getState, getAccounts } from "./lib/initializer";
+import { BigNumber } from "ethers";
+
+const cardsRegisteredProps = [
+  {
+    price: 5000,
+    percentage: 40,
+    maxMinted: 2000,
+  },
+  {
+    price: 2000,
+    percentage: 20,
+    maxMinted: 1500,
+  },
+];
+
+describe("Valhalla NFT Genesis", function () {
+  before(async () => {
+    await initialize();
+  });
+
+  it("Register NFT Variants", async () => {
+    const { nftGenesis, usdt } = getState();
+
+    // Use sequential loop to guarantee order (ID 0, ID 1)
+    for (const c of cardsRegisteredProps) {
+      await (
+        await nftGenesis.addNft(c.price, c.percentage, c.maxMinted)
+      ).wait();
+    }
+
+    const cardsRegisteredAmount = await nftGenesis.amountNftTypes();
+    expect(cardsRegisteredAmount).to.eq(2);
+
+    const decimals = await usdt.decimals(); // Should be 18
+
+    // Verify Card 0
+    const card0 = await nftGenesis.cardMap(0);
+    expect(card0.price).to.eq(
+      toBn(String(cardsRegisteredProps[0].price), decimals),
+    );
+    expect(card0.genesisPercentage).to.eq(cardsRegisteredProps[0].percentage);
+    expect(card0.maxMinted).to.eq(cardsRegisteredProps[0].maxMinted);
+
+    // Verify Card 1
+    const card1 = await nftGenesis.cardMap(1);
+    expect(card1.price).to.eq(
+      toBn(String(cardsRegisteredProps[1].price), decimals),
+    );
+    expect(card1.genesisPercentage).to.eq(cardsRegisteredProps[1].percentage);
+    expect(card1.maxMinted).to.eq(cardsRegisteredProps[1].maxMinted);
+  });
+
+  it("should be able to purchase nft Genesis", async () => {
+    const { usdt, nftGenesis } = getState();
+    const [admin, buyer] = await getAccounts(0, 2);
+    const price = toBn("5000", 18);
+
+    await usdt.connect(admin).transfer(buyer.address, price);
+
+    const balanceBefore = await usdt.balanceOf(buyer.address);
+    const nftBefore = await nftGenesis.balanceOf(buyer.address);
+
+    const approveTx = await usdt
+      .connect(buyer)
+      .approve(nftGenesis.address, price);
+    await approveTx.wait();
+
+    const tx = await nftGenesis.connect(buyer).buyMultipleNFT(0, 1);
+    await tx.wait();
+
+    const nftAfter = await nftGenesis.balanceOf(buyer.address);
+    const balanceAfter = await usdt.balanceOf(buyer.address);
+    const tokenId = await nftGenesis.tokenOfOwnerByIndex(buyer.address, 0);
+    const uri = await nftGenesis.tokenURI(tokenId);
+    const getMintedNFT = await nftGenesis.nftGenesis(buyer.address, 0);
+
+    // URI check
+    expect(uri).to.eq("https://globalnetwork.finance/api/image/genesis/0");
+
+    // Balance checks using BigNumber
+    expect(getMintedNFT.ownedNfts).to.eq(1);
+    expect(nftAfter.sub(nftBefore)).to.eq(1);
+
+    // Check USDT balance deduction
+    expect(balanceBefore.sub(balanceAfter)).to.eq(price);
+  });
+
+  it("should be able to purchase multiple nft Genesis", async () => {
+    const { usdt, nftGenesis } = getState();
+    const [admin, _, buyer] = await getAccounts(0, 3);
+    const amount = 3;
+    const pricePerUnit = toBn("5000", 18);
+    const totalPrice = pricePerUnit.mul(amount);
+
+    await usdt.connect(admin).transfer(buyer.address, totalPrice);
+
+    const balanceBefore = await usdt.balanceOf(buyer.address);
+    const nftBefore = await nftGenesis.balanceOf(buyer.address);
+
+    const approveTx = await usdt
+      .connect(buyer)
+      .approve(nftGenesis.address, totalPrice);
+    await approveTx.wait();
+
+    const tx = await nftGenesis.connect(buyer).buyMultipleNFT(0, amount);
+    await tx.wait();
+
+    const nftAfter = await nftGenesis.balanceOf(buyer.address);
+    const balanceAfter = await usdt.balanceOf(buyer.address);
+    const getMintedNFT = await nftGenesis.nftGenesis(buyer.address, 0);
+
+    expect(getMintedNFT.ownedNfts).to.eq(amount);
+    expect(nftAfter.sub(nftBefore)).to.eq(amount);
+    expect(balanceBefore.sub(balanceAfter)).to.eq(totalPrice);
+  });
+
+  it("make sure able to purchase nft", async () => {
+    // This purchases a Regular NFT (to trigger Genesis Pool distribution)
+    const { nft, crowd } = getState();
+    const [account] = await getAccounts(0);
+    const nftPrice = toBn("5000", 18);
+
+    // Need to approve enough for the purchase
+    const approveTx = await crowd
+      .connect(account)
+      .approve(nft.address, toBn("10000", 18));
+    await approveTx.wait();
+
+    const tx = await nft.connect(account).buy(0);
+    const receipt = await tx.wait();
+    expect(receipt.status).to.eq(1);
+  });
+
+  it("should be able to check current nft genesis rewards and have correct rewards", async () => {
+    const { nftGenesis } = getState();
+
+    // Logic:
+    // Regular NFT Price = 5000
+    // Genesis Pool Allocation = 5% of 5000 = 250
+    // Type 0 (Price 5000) Allocation = 40% of 250 = 100
+    // Reward Per Unit = 100 / MaxMinted(2000) = 0.05
+
+    const ONE_UNIT = toBn("1", 18);
+    const nftPrice = toBn("5000", 18);
+
+    const genesisAllocation = nftPrice.mul(5).div(100); // 250
+    const type0Allocation = genesisAllocation.mul(40).div(100); // 100
+    const rewardPerUnit = type0Allocation.div(2000); // 0.05
+
+    const [buyer, buyer2] = await getAccounts(1, 2);
+
+    // buyer has 1 NFT (bought in first test)
+    const rewards = await nftGenesis
+      .connect(buyer)
+      .myNftRewards(0, buyer.address);
+
+    // buyer2 has 3 NFTs (bought in second test)
+    const rewards2 = await nftGenesis
+      .connect(buyer2)
+      .myNftRewards(0, buyer2.address);
+
+    // Debug logs if needed
+    // console.log("Reward Per Unit:", fromBn(rewardPerUnit, 18));
+    // console.log("Buyer 1 Reward:", fromBn(rewards, 18));
+
+    expect(rewards).to.eq(rewardPerUnit);
+    expect(rewards2).to.eq(rewardPerUnit.mul(3));
+  });
+
+  it("should have correct value sended to receiverAddress", async () => {
+    const { crowd, nftGenesis } = getState();
+
+    // Logic:
+    // Total Type 0 allocation per Regular NFT sale = 100 tokens.
+    // Distributed = RewardPerUnit * TotalMinted
+    // Total Minted so far: 1 (buyer) + 3 (buyer2) = 4 units.
+    // Distributed = 0.05 * 4 = 0.2 tokens.
+    // Sent to Receiver (Undistributed) = 100 - 0.2 = 99.8 tokens.
+
+    const nftPrice = toBn("5000", 18);
+    const genesisAllocation = nftPrice.mul(5).div(100); // 250
+    const type0Allocation = genesisAllocation.mul(40).div(100); // 100
+    const rewardPerUnit = type0Allocation.div(2000); // 0.05
+
+    const totalMinted = 4;
+    const distributed = rewardPerUnit.mul(totalMinted);
+    // Correct logic: Receiver gets the rest of the GLOBAL genesis allocation
+    const expectedReceiverAndount = genesisAllocation.sub(distributed);
+
+    const receiverAddress = await nftGenesis.receiverAddress();
+    const balanceReceiver = await crowd.balanceOf(receiverAddress);
+
+    expect(balanceReceiver).to.eq(expectedReceiverAndount);
+  });
+
+  it("should have correct value genesisPool", async () => {
+    const { nftGenesis, crowd } = getState();
+    // Genesis Pool (contract balance) should hold the DISTRIBUTED amount that hasn't been claimed yet.
+    // i.e., 0.2 tokens.
+
+    const nftPrice = toBn("5000", 18);
+    const genesisAllocation = nftPrice.mul(5).div(100); // 250
+    const type0Allocation = genesisAllocation.mul(40).div(100); // 100
+    const rewardPerUnit = type0Allocation.div(2000); // 0.05
+    const totalMinted = 4;
+    const expectedPoolBalance = rewardPerUnit.mul(totalMinted);
+
+    const balance = await crowd.balanceOf(nftGenesis.address);
+    expect(balance).to.eq(expectedPoolBalance);
+  });
+
+  it("should be able to claim genesis rewards and have correct amount", async () => {
+    const { nftGenesis, crowd } = getState();
+    const [_, buyer, buyer2] = await getAccounts(0, 3); // buyer=idx 1, buyer2=idx 2
+
+    // buyer2 claims first (owns 3 NFTs, reward 0.15)
+    const balanceBefore2 = await crowd.balanceOf(buyer2.address);
+    await (await nftGenesis.connect(buyer2).claimRewards(0)).wait();
+    const balanceAfter2 = await crowd.balanceOf(buyer2.address);
+
+    // Expected reward for 3 units = 0.05 * 3 = 0.15
+    const expectedReward2 = toBn("0.15", 18); // 0.05 * 3
+    expect(balanceAfter2.sub(balanceBefore2)).to.eq(expectedReward2);
+
+    // buyer claims next (owns 1 NFT, reward 0.05)
+    const balanceBefore1 = await crowd.balanceOf(buyer.address);
+    await (await nftGenesis.connect(buyer).claimRewards(0)).wait();
+    const balanceAfter1 = await crowd.balanceOf(buyer.address);
+
+    const expectedReward1 = toBn("0.05", 18);
+    expect(balanceAfter1.sub(balanceBefore1)).to.eq(expectedReward1);
+
+    // Pool should be empty now for this distribution
+    const genesisPoolAfter = await nftGenesis.nftGenesisPool();
+    // Note: genesisPool tracks total value, but contract balance tracks unclaimed.
+    // nftGenesisPool variable in contract tracks *available* rewards?
+    // Let's check logic: claimRewards reduces nftGenesisPool.
+    // So it should be close to 0 (or exactly 0 if only this type exist).
+    // Actually there might be dust or other types if any.
+    // But since we only distributed to Type 0 and claimed all, it should be 0.
+
+    expect(genesisPoolAfter).to.eq(0);
+  });
+
+  it("prepare calculation for next test cases", async () => {
+    const { nft, crowd } = getState();
+    const accounts = await getAccounts(0, 6);
+    // Accounts 3, 4, 5
+
+    const transferAmount = toBn("25000", 18); // 25k (enough for Card #1)
+    const smallAmount = toBn("5000", 18); // 5k (Card #0)
+
+    // Setup balances
+    await (
+      await crowd
+        .connect(accounts[0])
+        .transfer(accounts[3].address, transferAmount)
+    ).wait();
+    await (
+      await crowd
+        .connect(accounts[0])
+        .transfer(accounts[4].address, smallAmount)
+    ).wait();
+    await (
+      await crowd
+        .connect(accounts[0])
+        .transfer(accounts[5].address, transferAmount)
+    ).wait();
+
+    // Approvals
+    await (
+      await crowd.connect(accounts[3]).approve(nft.address, transferAmount)
+    ).wait();
+    await (
+      await crowd.connect(accounts[4]).approve(nft.address, smallAmount)
+    ).wait();
+    await (
+      await crowd.connect(accounts[5]).approve(nft.address, transferAmount)
+    ).wait();
+
+    // Buy NFTs to generate more rewards
+    // Card #1 sales generate 5% to Genesis Pool too.
+    // Price 25000 -> 5% = 1250.
+    // Type 0 allocation (40%) = 500.
+    // Reward per unit = 500 / 2000 = 0.25.
+
+    await (await nft.connect(accounts[3]).buy(1)).wait(); // +0.25 reward per unit
+    await (await nft.connect(accounts[4]).buy(0)).wait(); // +0.05 reward per unit
+    await (await nft.connect(accounts[5]).buy(1)).wait(); // +0.25 reward per unit
+
+    // Total new reward per unit = 0.25 + 0.05 + 0.25 = 0.55
+  });
+
+  it("should be able to claim rewards automatically when already have a genesis nft and then buy another", async () => {
+    const { crowd, nftGenesis, usdt } = getState();
+    const [admin, _, buyer] = await getAccounts(0, 3); // buyer2 (idx 2)
+
+    // buyer2 currently owns 3 NFTs.
+    // Previous rewards were claimed.
+    // New rewards generated in "prepare calculation" step: 0.55 per unit.
+    // Total pending reward = 0.55 * 3 = 1.65.
+
+    const pendingRewards = await nftGenesis
+      .connect(buyer)
+      .myNftRewards(0, buyer.address);
+    // Verify pending expectation
+    const expectedPending = toBn("0.55", 18).mul(3);
+
+    // Allow small rounding diff if any, but with integer math usually exact
+    expect(pendingRewards).to.eq(expectedPending);
+
+    const balanceCROWDBefore = await crowd.balanceOf(buyer.address);
+
+    // Buy 3 more Genesis NFTs
+    const pricePerUnit = toBn("5000", 18);
+    const cost = pricePerUnit.mul(3);
+
+    await usdt.connect(admin).transfer(buyer.address, cost);
+    await (await usdt.connect(buyer).approve(nftGenesis.address, cost)).wait();
+
+    // This buy action should trigger auto-claim of the 1.65 CROWD rewards
+    await (await nftGenesis.connect(buyer).buyMultipleNFT(0, 3)).wait();
+
+    const balanceCROWDAfter = await crowd.balanceOf(buyer.address);
+
+    // Check if rewards were received
+    expect(balanceCROWDAfter.sub(balanceCROWDBefore)).to.eq(expectedPending);
+
+    // New rewards should be 0 immediately after buy (for the old execution point)
+    // But wait, the marker updates only when distributed.
+    // The claimed amount is reset.
+    const newPending = await nftGenesis
+      .connect(buyer)
+      .myNftRewards(0, buyer.address);
+    expect(newPending).to.eq(0);
+  });
+
+  it("should be able to buy different variant nft", async () => {
+    const { usdt, nftGenesis } = getState();
+    const [admin, buyer] = await getAccounts(0, 2); // reuse buyer (idx 1)
+
+    // Buy Type 1 (Price 2000)
+    const price = toBn("2000", 18);
+
+    await usdt.connect(admin).transfer(buyer.address, price);
+    await (await usdt.connect(buyer).approve(nftGenesis.address, price)).wait();
+
+    const nftBefore = await nftGenesis.balanceOf(buyer.address);
+
+    await (await nftGenesis.connect(buyer).buyMultipleNFT(1, 1)).wait();
+
+    const nftAfter = await nftGenesis.balanceOf(buyer.address);
+    expect(nftAfter.sub(nftBefore)).to.eq(1);
+
+    // Check ownership of Type 1
+    const cardInfo = await nftGenesis.nftGenesis(buyer.address, 1);
+    expect(cardInfo.ownedNfts).to.eq(1);
+
+    // URI Check for Type 1
+    // buyer had 1 type 0. bought 1 type 1. Total 2. Index 1?
+    // tokenOfOwnerByIndex might return in order.
+    // Let's find the token with cardId 1.
+    // This part is tricky without knowing exact token ID logic, but usually append.
+    // We can just trust cardInfo verification above.
+  });
+
+  it("should be able to transfer NFT", async () => {
+    const { nftGenesis, crowd } = getState();
+    const [owner, receiver] = await getAccounts(2, 2); // owner=buyer2(idx2), receiver=idx3
+
+    // Owner (buyer2) has 3 (initial) + 3 (new) = 6 NFTs of Type 0.
+    // Receiver (idx3) has 0 NFTs.
+
+    const ownerCardBefore = await nftGenesis.nftGenesis(owner.address, 0);
+    const receiverCardBefore = await nftGenesis.nftGenesis(receiver.address, 0);
+
+    // console.log("Owner NFTs:", ownerCardBefore.ownedNfts.toString());
+
+    // Transfer 1 NFT from Owner to Receiver via token ID
+    const tokenId = await nftGenesis.tokenOfOwnerByIndex(owner.address, 0); // Get first token
+
+    await (
+      await nftGenesis
+        .connect(owner)
+        .transferFrom(owner.address, receiver.address, tokenId)
+    ).wait();
+
+    const ownerCardAfter = await nftGenesis.nftGenesis(owner.address, 0);
+    const receiverCardAfter = await nftGenesis.nftGenesis(receiver.address, 0);
+
+    expect(ownerCardAfter.ownedNfts).to.eq(ownerCardBefore.ownedNfts.sub(1));
+    expect(receiverCardAfter.ownedNfts).to.eq(
+      receiverCardBefore.ownedNfts.add(1),
+    );
+  });
+});

package/test/nft_purchase.test.ts

@@ -0,0 +1,210 @@
+import { expect } from "chai";
+import { fromBn, toBn } from "evm-bn";
+import { initialize, getState, getAccounts } from "./lib/initializer";
+
+describe("Valhalla NFT Purchase", function () {
+  before(async () => {
+    await initialize();
+  });
+
+  it("make sure able to purchase nft", async () => {
+    const { nft, crowd } = getState();
+    const [account] = await getAccounts(0);
+    // Approve full NFT price - contract handles all transfers including genesis pool
+    const approveTx = await crowd
+      .connect(account)
+      .approve(nft.address, toBn("10000", 18));
+    await approveTx.wait();
+
+    const tx = await nft.connect(account).buy(0);
+    const receipt = await tx.wait();
+    expect(receipt.status).to.eq(1);
+  });
+
+  it("should fail to purchase nft if not registered", async () => {
+    const { nft, crowd } = getState();
+    const [unregisteredUser] = await getAccounts(50, 1); // Use new account
+
+    // Transfer token to unregistered user
+    const [admin] = await getAccounts(0);
+    await crowd
+      .connect(admin)
+      .transfer(unregisteredUser.address, toBn("10000", 18));
+
+    // Approve
+    await crowd
+      .connect(unregisteredUser)
+      .approve(nft.address, toBn("10000", 18));
+
+    // Expect revert
+    await expect(nft.connect(unregisteredUser).buy(0)).to.be.revertedWith(
+      "Registration required",
+    );
+  });
+
+  it("make sure total supply is correct", async () => {
+    const { nft } = getState();
+    const totalSupply = await nft.totalSupply();
+    expect(totalSupply.toNumber()).to.eq(1);
+  });
+
+  it("make sure global pool is correct (17%)", async () => {
+    const { nft } = getState();
+    const globalPool = await nft.getGlobalPool();
+    const calculation = toBn(String((5000 * 17) / 100), 18);
+    const isAccurate = calculation.eq(globalPool.claimable);
+    expect(isAccurate).to.eq(true);
+  });
+
+  it("make sure fee receiver reward is correct (20%)", async () => {
+    const { valhalla, crowd } = getState();
+    const feeReceiverAddress = await valhalla.feeReceiverAddress();
+    const feeReceiverAddress2 = await valhalla.feeReceiverAddress2();
+    const balanceFee = await crowd.balanceOf(feeReceiverAddress);
+    const balanceFee2 = await crowd.balanceOf(feeReceiverAddress2);
+
+    // Fee receiver should get 20% total (10% each)
+    const rewardCalc = toBn(String((5000 * 20) / 100), 18);
+    const halfFeeReward = rewardCalc.div(2);
+
+    expect(halfFeeReward).to.eq(balanceFee);
+    expect(halfFeeReward).to.eq(balanceFee2);
+  });
+
+  it("make sure 50% is burned", async () => {
+    const { crowd } = getState();
+    const totalSupply = await crowd.totalSupply();
+
+    // Initial supply is 1,000,000,000 CROWD
+    // After buying NFT for 5000 CROWD, 50% (2500 CROWD) should be burned
+    const initialSupply = toBn("1000000000", 18);
+    const burnedAmount = toBn(String((5000 * 50) / 100), 18);
+    const expectedSupply = initialSupply.sub(burnedAmount);
+
+    expect(totalSupply).to.eq(expectedSupply);
+  });
+
+  it("make sure direct referral gets 8% reward", async () => {
+    const { nft, crowd, valhalla, usdt, nftGenesis } = getState();
+    const [admin] = await getAccounts(0, 1);
+    const [referrer, buyer] = await getAccounts(15, 2);
+
+    // Register referrer first (referrer needs to be registered)
+    const transferUsdtToReferrerTx = await usdt
+      .connect(admin)
+      .transfer(referrer.address, toBn("100", 18));
+    await transferUsdtToReferrerTx.wait();
+
+    const approveUsdtReferrerTx = await usdt
+      .connect(referrer)
+      .approve(valhalla.address, toBn("100", 18));
+    await approveUsdtReferrerTx.wait();
+
+    const registerReferrerTx = await valhalla
+      .connect(referrer)
+      .register(admin.address);
+    await registerReferrerTx.wait();
+
+    // Transfer USDT for registration fee
+    const transferUsdtTx = await usdt
+      .connect(admin)
+      .transfer(buyer.address, toBn("100", 18));
+    await transferUsdtTx.wait();
+
+    // Approve USDT for registration
+    const approveUsdtTx = await usdt
+      .connect(buyer)
+      .approve(valhalla.address, toBn("100", 18));
+    await approveUsdtTx.wait();
+
+    // Transfer CROWD to buyer for NFT purchase
+    const transferTx = await crowd
+      .connect(admin)
+      .transfer(buyer.address, toBn("10000", 18));
+    await transferTx.wait();
+
+    // Register buyer with referrer as direct referral
+    const registerTx = await valhalla.connect(buyer).register(referrer.address);
+    await registerTx.wait();
+
+    // Get referrer's reward before purchase
+    const rewardBefore = await nft.rewardMap(referrer.address);
+
+    // Buyer approves and purchases NFT (full amount for genesis pool transfer)
+    const approveTx = await crowd
+      .connect(buyer)
+      .approve(nft.address, toBn("10000", 18));
+    await approveTx.wait();
+
+    const approveGenesisTx = await crowd
+      .connect(buyer)
+      .approve(nftGenesis.address, toBn("10000", 18));
+    await approveGenesisTx.wait();
+
+    const buyTx = await nft.connect(buyer).buy(0);
+    await buyTx.wait();
+
+    // Get referrer's reward after purchase
+    const rewardAfter = await nft.rewardMap(referrer.address);
+    const rewardReceived = rewardAfter.sub(rewardBefore);
+
+    // Direct referral should get 8% of NFT price
+    const expectedReward = toBn(String((5000 * 8) / 100), 18);
+    expect(rewardReceived).to.eq(expectedReward);
+  });
+
+  it("make sure genesis pool receives 5%", async () => {
+    const { nft, crowd, nftGenesis, valhalla, usdt } = getState();
+    const [admin] = await getAccounts(0, 1);
+    const [referrer] = await getAccounts(14, 1);
+    const [buyer] = await getAccounts(20, 1);
+
+    // Transfer USDT for registration fee
+    const transferUsdtTx = await usdt
+      .connect(admin)
+      .transfer(buyer.address, toBn("100", 18));
+    await transferUsdtTx.wait();
+
+    // Approve USDT for registration
+    const approveUsdtTx = await usdt
+      .connect(buyer)
+      .approve(valhalla.address, toBn("100", 18));
+    await approveUsdtTx.wait();
+
+    // Register buyer first
+    const registerTx = await valhalla.connect(buyer).register(referrer.address);
+    await registerTx.wait();
+
+    // Transfer CROWD to buyer
+    const transferTx = await crowd
+      .connect(admin)
+      .transfer(buyer.address, toBn("10000", 18));
+    await transferTx.wait();
+
+    // Get genesis pool balance before purchase
+    const genesisAddress = await nftGenesis.receiverAddress();
+    const genesisBalanceBefore = await crowd.balanceOf(genesisAddress);
+
+    // Buyer approves and purchases NFT (full amount for genesis pool transfer)
+    const approveTx = await crowd
+      .connect(buyer)
+      .approve(nft.address, toBn("10000", 18));
+    await approveTx.wait();
+
+    const approveGenesisTx = await crowd
+      .connect(buyer)
+      .approve(nftGenesis.address, toBn("10000", 18));
+    await approveGenesisTx.wait();
+
+    const buyTx = await nft.connect(buyer).buy(0);
+    await buyTx.wait();
+
+    // Get genesis pool balance after purchase
+    const genesisBalanceAfter = await crowd.balanceOf(genesisAddress);
+    const genesisReceived = genesisBalanceAfter.sub(genesisBalanceBefore);
+
+    // Genesis pool should receive 5% of NFT price
+    const expectedGenesisAmount = toBn(String((5000 * 5) / 100), 18);
+    expect(genesisReceived).to.eq(expectedGenesisAmount);
+  });
+});