gn-contract 1.0.0

package/.prettierrc

@@ -0,0 +1,15 @@
+{
+  "overrides": [
+    {
+      "files": "*.sol",
+      "options": {
+        "printWidth": 80,
+        "tabWidth": 2,
+        "useTabs": false,
+        "singleQuote": false,
+        "bracketSpacing": false,
+        "explicitTypes": "always"
+      }
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,14 @@
+# Sample Hardhat Project
+
+This project demonstrates a basic Hardhat use case. It comes with a sample contract, a test for that contract, and a Hardhat Ignition module that deploys that contract.
+
+Try running some of the following tasks:
+
+```shell
+npx hardhat help
+npx hardhat test
+REPORT_GAS=true npx hardhat test
+npx hardhat node
+npx hardhat ignition deploy ./ignition/modules/Lock.ts
+```
+# gn-contract

package/constants/getter.ts

@@ -0,0 +1,4 @@
+export const getter = {
+  usdt: { address: "0x15D734dD9C92Ae6c298197890312B3A349Aa0Ae6" },
+  nftGenesis: { address: "0xd90EBefb468d78dd9d092389269484CC5f563304" },
+};

package/constants/rootAddress.ts

@@ -0,0 +1,22 @@
+export const rootAdressList = [
+  "0xbbf56FB6878F4f6665507495B059901a5124FDdE",
+  "0xa9968A081e9119ECb17e65b5B00504A770E7554D",
+  "0x4Ab1539b21B7d9aBB5a535467deD7bf155A30223",
+  "0xaF8014763e6c8919767125D235730b459FDbA364",
+  "0xfC6b100A7B23E2cB7952D8f5Ece1A36727532c4a",
+  "0xde668F1cd8C4F38127C4B43a9A711e6615a2A080",
+  "0xd9682cf0870cFaDc307baEDFD8A0d1F92Db1e187",
+  "0x0387376b07D3Ae19E56bfB4992208360c4F604f0",
+  "0xA6BcA768eDCEC76565918E93d257e981c14064c6",
+  "0xD554c09Ea646001A72B59f154D831258878e3ee9",
+  "0xc0A2C50E560eA064aA9d863A8A1005D553b23a67",
+  "0x9c963c63e5f8669fa07e85a8711e36C0D49544a2",
+  "0xB8f8C74C740fD806cA267EE2B8bB733AC36642E7",
+  "0x9ADeB9088d0D091f7C5dbf0bc9864ccd0aD9A2d4",
+  "0x65CA460b1398d1d335edA4186fa2213fBfe6B815",
+];
+
+export const feeReceiverAddress = "0xFdA829C6E8825437365E666cBE3A07311c7B4337";
+export const feeReceiverAddress2 = "0x456af512778C41cDf342b0778C49A3578C0A6C7E";
+export const reserveAddress = "0xa1BA34674C0920d3113f2DDBDe6b7e586403c88B";
+export const genesisPayment = "0x883EbD6056653712EFebd2787489fCdd9e63AfC4";

package/contracts/CROWD.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
+
+contract CROWD is ERC20, ERC20Burnable, Ownable {
+  address public minterContract;
+
+  // this is not real name, please check the contract first before deploying !
+  constructor() ERC20("Crowd Strike", "CROWD") {
+    _mint(msg.sender, 1_000_000_000 * 10 ** 18);
+  }
+
+  function decimals() public pure override returns (uint8) {
+    return 18;
+  }
+
+  function setMinterContract(address _minterContract) public onlyOwner {
+    require(
+      _minterContract != address(minterContract),
+      "minter contract already set"
+    );
+    minterContract = _minterContract;
+  }
+
+  function mintForFarm(uint amount, address target) external {
+    require(msg.sender == minterContract, "Unauthorized minter");
+    _mint(target, amount);
+  }
+}

package/contracts/CUSDT.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
+
+contract CUSDT is ERC20, ERC20Burnable, Ownable {
+  address public minterContract;
+
+  // this is not real name, please check the contract first before deploying !
+  constructor() ERC20("Crowd United State Dollar", "CUSDT") {
+    _mint(msg.sender, 1_000_000_000 * 10 ** 18);
+  }
+
+  function decimals() public pure override returns (uint8) {
+    return 18;
+  }
+
+  function setMinterContract(address _minterContract) public onlyOwner {
+    require(
+      _minterContract != address(minterContract),
+      "minter contract already set"
+    );
+    minterContract = _minterContract;
+  }
+
+  function mintForFarm(uint amount, address target) external {
+    require(msg.sender == minterContract, "Unauthorized minter");
+    _mint(target, amount);
+  }
+}

package/contracts/NFT.sol

@@ -0,0 +1,499 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "./CROWD.sol";
+import "./Network.sol";
+import "./lib/ValhallaPool.sol";
+import "./lib/NFTHelpers.sol";
+import "./NFTGenesis.sol";
+
+contract NFT is
+  ValhallaPool,
+  Initializable,
+  OwnableUpgradeable,
+  ERC721Upgradeable,
+  ERC721EnumerableUpgradeable,
+  UUPSUpgradeable
+{
+  using CountersUpgradeable for CountersUpgradeable.Counter;
+  using StringsUpgradeable for uint256;
+  using NFTHelpers for *;
+
+  uint256 private randNonce;
+
+  mapping(uint => OwnedToken) public ownedTokenMap;
+  mapping(uint => Card) public cardMap;
+  mapping(address => uint) public totalValueMap;
+  mapping(address => uint) public rewardMap;
+  mapping(address => uint) public referralRewardMap;
+  mapping(address => uint) public farmMatchingRewardMap;
+  mapping(address => uint) public rankRewardClaimedAtMap;
+  CROWD public gnetERC20;
+  Network public valhalla;
+
+  CountersUpgradeable.Counter private _tokenIdCounter;
+  CountersUpgradeable.Counter private _cardIdCounter;
+
+  NFTGenesis public nftGenesis;
+
+  // events
+  event Buy(address indexed _from, uint indexed _tokenId);
+  event Farm(uint indexed _tokenId, uint _value);
+  event ClaimReward(address indexed _from, uint value);
+  event ClaimRankReward(address indexed _from, uint value);
+  event DirectReferralReward(
+    address indexed referrer,
+    address indexed buyer,
+    uint value
+  );
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor() {
+    _disableInitializers();
+  }
+
+  function initialize(CROWD _gnetERC20, Network _valhalla) public initializer {
+    // this is not a real name, please check this contract before deploy
+    __Ownable_init();
+    __ERC721_init("CrowdStrikeNFT", "CROWDNFT");
+    __ERC721Enumerable_init();
+    __UUPSUpgradeable_init();
+
+    gnetERC20 = _gnetERC20;
+    valhalla = _valhalla;
+
+    /**
+     * initiate 6 card on deployment
+     */
+    uint[6] memory initialCardPriceList = [
+      uint(5000),
+      uint(25000),
+      uint(100000),
+      uint(500000),
+      uint(2500000),
+      uint(10000000)
+    ];
+    for (uint i = 0; i < initialCardPriceList.length; i++) {
+      uint _cardId = _cardIdCounter.current();
+      Card storage _card = cardMap[_cardId];
+      _card.price = initialCardPriceList[_cardId] * 10 ** gnetERC20.decimals();
+      _card.halfingPercentage = 100;
+      _card.isMintable = true;
+      _cardIdCounter.increment();
+    }
+  }
+
+  function _authorizeUpgrade(
+    address newImplementation
+  ) internal override onlyOwner {}
+
+  // The following functions are overrides required by Solidity.
+
+  function _beforeTokenTransfer(
+    address from,
+    address to,
+    uint256 tokenId,
+    uint256 batchSize
+  ) internal override(ERC721Upgradeable, ERC721EnumerableUpgradeable) {
+    super._beforeTokenTransfer(from, to, tokenId, batchSize);
+  }
+
+  function supportsInterface(
+    bytes4 interfaceId
+  )
+    public
+    view
+    override(ERC721Upgradeable, ERC721EnumerableUpgradeable)
+    returns (bool)
+  {
+    return super.supportsInterface(interfaceId);
+  }
+
+  function _random(uint256 modulus) private returns (uint256) {
+    randNonce++;
+    return
+      uint256(
+        keccak256(abi.encodePacked(block.timestamp, msg.sender, randNonce))
+      ) % modulus;
+  }
+
+  function tokenURI(
+    uint256 tokenId
+  ) public view override returns (string memory) {
+    _requireMinted(tokenId);
+
+    string memory baseURI = _baseURI();
+    OwnedToken memory ownedToken = ownedTokenMap[tokenId];
+    uint cardId = ownedToken.cardId;
+    return
+      bytes(baseURI).length > 0
+        ? string(abi.encodePacked(baseURI, cardId.toString()))
+        : "";
+  }
+
+  function _baseURI() internal pure override returns (string memory) {
+    return "https://crowdstrike.club/api/image/";
+  }
+
+  /**
+   * calculate the probability of farm percentage
+   */
+  function _getRandomFarmPercentage() private returns (uint256) {
+    uint256 rand = _random(1000);
+    return NFTHelpers.getRandomFarmPercentage(rand);
+  }
+
+  /**
+   * calculate reward per seconds base on its own percentage
+   */
+  function getFarmValue(uint tokenId) public view returns (uint256) {
+    OwnedToken storage _tokenMetadata = ownedTokenMap[tokenId];
+    Card memory card = cardMap[_tokenMetadata.cardId];
+    return
+      NFTHelpers.calculateFarmValue(
+        _tokenMetadata.mintedAt,
+        _tokenMetadata.lastFarmedAt,
+        _tokenMetadata.percentage,
+        _tokenMetadata.mintingPrice,
+        card.halfingPercentage
+      );
+  }
+
+  function buy(uint cardId) public notInBlacklist {
+    bool is_registered;
+    Rank rank;
+    address directReferrer;
+    (is_registered, , rank, directReferrer, , , , ) = valhalla.accountMap(
+      msg.sender
+    );
+    address feeReceiver = valhalla.feeReceiverAddress();
+    address feeReceiver2 = valhalla.feeReceiverAddress2();
+    bool isRankRewardClaimable = valhalla.isRankRewardClaimable();
+    Card storage _card = cardMap[cardId];
+
+    require(isRankRewardClaimable == false, "Market closed");
+    require(is_registered, "Registration required");
+    require(_card.price > 0, "Invalid card");
+    require(_card.isMintable, "Card is not mintable");
+
+    uint32[7] memory maxBuy = [
+      100_000,
+      200_000,
+      1000_000,
+      5_000_000,
+      20_000_000,
+      100_000_000,
+      500_000_000
+    ];
+
+    for (uint i = 0; i < 7; i++) {
+      if (uint(rank) == i) {
+        require(
+          _card.price + totalValueMap[msg.sender] <=
+            maxBuy[i] * 10 ** gnetERC20.decimals(),
+          "Max Buy Error"
+        );
+      }
+    }
+
+    uint distributeGenesis = (_card.price * 5) / 100;
+    gnetERC20.transferFrom(
+      msg.sender,
+      address(this),
+      _card.price - distributeGenesis
+    );
+
+    _storeGlobalPool((_card.price * 17) / 100);
+    genesisPoolResolver(distributeGenesis);
+    uint tax = (_card.price * 20) / 100;
+    uint halfTax = tax / 2;
+    // rewardMap[feeReceiver] += halfTax;
+    // rewardMap[feeReceiver2] += halfTax;
+    gnetERC20.transfer(feeReceiver, halfTax);
+    gnetERC20.transfer(feeReceiver2, halfTax);
+    gnetERC20.burn((_card.price * 50) / 100);
+
+    if (directReferrer != address(0)) {
+      uint referralReward = (_card.price * 8) / 100;
+      rewardMap[directReferrer] += referralReward;
+      referralRewardMap[directReferrer] += referralReward;
+      emit DirectReferralReward(directReferrer, msg.sender, referralReward);
+    }
+
+    uint256 tokenId = _tokenIdCounter.current();
+    OwnedToken storage _purchasedToken = ownedTokenMap[tokenId];
+    _purchasedToken.cardId = cardId;
+    _purchasedToken.mintingPrice = _card.price;
+    _purchasedToken.mintedAt = block.timestamp;
+    _purchasedToken.lastFarmedAt = block.timestamp;
+    _purchasedToken.percentage = _getRandomFarmPercentage();
+
+    _tokenIdCounter.increment();
+    _safeMint(msg.sender, tokenId);
+    emit Buy(msg.sender, tokenId);
+  }
+
+  function withdrawAllGenesisPool() public onlyOwner {
+    PoolType storage genesisPool = poolMap[GENESIS_POOL_KEY];
+    gnetERC20.transfer(msg.sender, genesisPool.claimable);
+    genesisPool.claimable = 0;
+    genesisPool.valueLeft = 0;
+  }
+
+  function _getReferrerFarmMatchingPercentage(
+    uint level,
+    address referrer
+  ) private view returns (uint) {
+    Rank rank;
+    (, , rank, , , , , ) = valhalla.accountMap(referrer);
+
+    return
+      NFTHelpers.getReferrerMatchingPercentage(
+        level,
+        uint8(rank),
+        totalValueMap[referrer],
+        gnetERC20.decimals()
+      );
+  }
+
+  function setNFTGenesis(NFTGenesis _nftGenesis) public onlyOwner {
+    nftGenesis = _nftGenesis;
+  }
+
+  function genesisPoolResolver(uint _genesisValue) private {
+    uint storedGenesisValue = 0;
+    uint amountNftTypes = nftGenesis.amountNftTypes();
+    address receiver = nftGenesis.receiverAddress();
+
+    for (uint256 i = 0; i < amountNftTypes; i++) {
+      (, uint genesisPercentage, uint totalMinted, uint maxMinted) = nftGenesis
+        .cardMap(i);
+      uint valueDistributed = ((_genesisValue * genesisPercentage) /
+        100 /
+        maxMinted) * totalMinted;
+      storedGenesisValue += valueDistributed;
+      if (valueDistributed == 0) continue;
+      nftGenesis.distributeGenesisRewards(i, valueDistributed);
+    }
+
+    gnetERC20.transferFrom(msg.sender, address(nftGenesis), storedGenesisValue);
+    gnetERC20.transferFrom(
+      msg.sender,
+      receiver,
+      _genesisValue - storedGenesisValue
+    );
+  }
+
+  function farm(uint tokenId) public notInBlacklist {
+    require(ownerOf(tokenId) == msg.sender, "caller is not owner");
+    require(ownedTokenMap[tokenId].isBlackListed == false, "token blacklisted");
+    uint reward = getFarmValue(tokenId);
+    require(reward > 0, "No reward to farm");
+    uint tax = (reward * 10) / 100;
+    uint halTax = tax / 2;
+    gnetERC20.mintForFarm(halTax, valhalla.feeReceiverAddress());
+    gnetERC20.mintForFarm(halTax, valhalla.feeReceiverAddress2());
+    gnetERC20.mintForFarm(reward - tax, msg.sender);
+
+    Rank rank;
+    address referrer;
+    (, , rank, referrer, , , , ) = valhalla.accountMap(msg.sender);
+    for (uint i = 1; i <= 100; i++) {
+      if (referrer == address(0)) break;
+      uint matchingPercentage = _getReferrerFarmMatchingPercentage(i, referrer);
+      if (matchingPercentage > 0) {
+        uint uplineReward = (reward * matchingPercentage) / 100;
+        gnetERC20.mintForFarm(uplineReward, address(this));
+        rewardMap[referrer] += uplineReward;
+        farmMatchingRewardMap[referrer] += uplineReward;
+      }
+      (, , rank, referrer, , , , ) = valhalla.accountMap(referrer);
+    }
+    ownedTokenMap[tokenId].lastFarmedAt = block.timestamp;
+    emit Farm(tokenId, reward);
+  }
+
+  function startClaimingRankReward() external {
+    require(msg.sender == address(valhalla), "Only valhalla can call");
+    PoolType storage globalPool = poolMap[GLOBAL_POOL_KEY];
+    globalPool.valueLeft = globalPool.claimable;
+  }
+
+  function stopClaimingRankReward() external {
+    require(msg.sender == address(valhalla), "Only valhalla can call");
+    PoolType storage globalPool = poolMap[GLOBAL_POOL_KEY];
+    globalPool.claimable = globalPool.valueLeft;
+    globalPool.valueLeft = 0;
+  }
+
+  function getMyRankReward(address _accountAddress) public view returns (uint) {
+    Rank rank;
+    (, , rank, , , , , ) = valhalla.accountMap(_accountAddress);
+    PoolType storage globalPool = poolMap[GLOBAL_POOL_KEY];
+    bool isRankRewardClaimable = valhalla.isRankRewardClaimable();
+    if (globalPool.valueLeft == 0) return 0;
+    uint rankRewardClaimableAt = valhalla.rankRewardClaimableAt();
+    if (isRankRewardClaimable == false) return 0;
+    if (rankRewardClaimedAtMap[_accountAddress] >= rankRewardClaimableAt)
+      return 0;
+    if (rank == Rank.NoRank) return 0;
+    uint commonRankDistribution = 0;
+    uint rareRankDistribution = 0;
+    uint superRareRankDistribution = 0;
+    uint epicRankDistribution = 0;
+    uint legendRankDistribution = 0;
+    uint superLegendRankDistribution = 0;
+    (
+      commonRankDistribution,
+      rareRankDistribution,
+      superRareRankDistribution,
+      epicRankDistribution,
+      legendRankDistribution,
+      superLegendRankDistribution
+    ) = valhalla.rankDistribution();
+    uint distribution = 0;
+    uint base = 0;
+    if (rank == Rank.Common) {
+      distribution = commonRankDistribution;
+      base = (globalPool.claimable * 3) / 100;
+    }
+    if (rank == Rank.Rare) {
+      distribution = rareRankDistribution;
+      base = (globalPool.claimable * 7) / 100;
+    }
+    if (rank == Rank.SuperRare) {
+      distribution = superRareRankDistribution;
+      base = (globalPool.claimable * 12) / 100;
+    }
+    if (rank == Rank.Epic) {
+      distribution = epicRankDistribution;
+      base = (globalPool.claimable * 18) / 100;
+    }
+    if (rank == Rank.Legend) {
+      distribution = legendRankDistribution;
+      base = (globalPool.claimable * 26) / 100;
+    }
+    if (rank == Rank.SuperLegend) {
+      distribution = superLegendRankDistribution;
+      base = (globalPool.claimable * 34) / 100;
+    }
+
+    return base / distribution;
+  }
+
+  function claimRankReward() public notInBlacklist {
+    Rank rank;
+    (, , rank, , , , , ) = valhalla.accountMap(msg.sender);
+    PoolType storage globalPool = poolMap[GLOBAL_POOL_KEY];
+    uint myReward = getMyRankReward(msg.sender);
+    uint nftValue = totalValueMap[msg.sender];
+
+    uint32[7] memory eligValue = [
+      0,
+      50_000,
+      200_000,
+      1_000_000,
+      5_000_000,
+      25_000_000,
+      100_000_000
+    ];
+
+    require(myReward > 0, "No Reward can be claimed");
+
+    for (uint i = 0; i < 7; i++) {
+      if (uint(rank) == i && rank != Rank.NoRank) {
+        require(
+          nftValue >= eligValue[i] * 10 ** gnetERC20.decimals(),
+          "Not Eligible"
+        );
+      }
+    }
+
+    uint tax = (myReward * 10) / 100;
+    uint halfTax = tax / 2;
+    gnetERC20.transfer(valhalla.feeReceiverAddress(), halfTax);
+    gnetERC20.transfer(valhalla.feeReceiverAddress2(), halfTax);
+    gnetERC20.transfer(msg.sender, myReward - tax);
+    rankRewardClaimedAtMap[msg.sender] = block.timestamp;
+    globalPool.valueLeft -= myReward;
+    emit ClaimRankReward(msg.sender, myReward);
+  }
+
+  function claimReward() public notInBlacklist {
+    uint _reward = rewardMap[msg.sender];
+    address feeReceiver = valhalla.feeReceiverAddress();
+    address feeReceiver2 = valhalla.feeReceiverAddress2();
+    require(_reward > 0, "No reward to be claimed");
+    // apply 10% tax
+    uint tax = (_reward * 10) / 100;
+    uint halfTax = tax / 2;
+    gnetERC20.transfer(feeReceiver, halfTax);
+    gnetERC20.transfer(feeReceiver2, halfTax);
+    gnetERC20.transfer(msg.sender, _reward - tax);
+    rewardMap[msg.sender] = 0;
+    referralRewardMap[msg.sender] = 0; // TAMBAH INI
+    farmMatchingRewardMap[msg.sender] = 0;
+
+    emit ClaimReward(msg.sender, _reward - tax);
+  }
+
+  function blacklistToken(uint tokenId) public onlyAdmin {
+    OwnedToken storage token = ownedTokenMap[tokenId];
+    token.isBlackListed = true;
+  }
+
+  function _afterTokenTransfer(
+    address from,
+    address to,
+    uint256 tokenId,
+    uint256 batchSize
+  ) internal virtual override {
+    super._afterTokenTransfer(from, to, tokenId, batchSize);
+    uint256 price = ownedTokenMap[tokenId].mintingPrice;
+    if (from == address(0)) {
+      totalValueMap[to] += price;
+    } else if (to == address(0)) {
+      totalValueMap[from] -= price;
+    } else {
+      totalValueMap[from] -= price;
+      totalValueMap[to] += price;
+    }
+  }
+
+  modifier onlyAdmin() {
+    require(
+      valhalla.hasRole(valhalla.DEFAULT_ADMIN_ROLE(), msg.sender),
+      "Only Admin can perform action"
+    );
+    _;
+  }
+
+  modifier onlyStaff() {
+    require(
+      valhalla.hasRole(valhalla.DEFAULT_ADMIN_ROLE(), msg.sender) ||
+        valhalla.hasRole(valhalla.STAFF_ROLE(), msg.sender),
+      "Only Admin can perform action"
+    );
+    _;
+  }
+
+  modifier notInBlacklist() {
+    require(
+      valhalla.blacklistedAddressMap(msg.sender) != true,
+      "Address blacklisted"
+    );
+    _;
+  }
+
+  modifier onlyGenesis() {
+    require(msg.sender == address(nftGenesis), "Transaction Prohibited");
+    _;
+  }
+}