gn-contracts 1.0.0 → 1.0.2

package/contracts/NFT.sol

@@ -168,9 +168,8 @@ contract NFT is
 
   function buy(uint cardId) public notInBlacklist {
     bool is_registered;
-    Rank rank;
     address directReferrer;
-    (is_registered, , rank, directReferrer, , , , ) = valhalla.accountMap(
+    (is_registered, , , directReferrer, , , , ) = valhalla.accountMap(
       msg.sender
     );
     address feeReceiver = valhalla.feeReceiverAddress();
@@ -183,61 +182,57 @@ contract NFT is
     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
-    ];
+    uint distributeGenesis = (_card.price * 5) / 100;
+    uint globalPoolAmount = (_card.price * 17) / 100;
+    uint tax = (_card.price * 20) / 100;
+    uint halfTax = tax / 2;
+    uint burnAmount = (_card.price * 50) / 100;
+    uint referralReward = directReferrer != address(0) ? (_card.price * 8) / 100 : 0;
+    
+    uint totalNeeded = _card.price;
+    
+    require(
+        gnetERC20.allowance(msg.sender, address(this)) >= totalNeeded,
+        "Insufficient allowance"
+    );
+    require(
+        gnetERC20.balanceOf(msg.sender) >= totalNeeded,
+        "Insufficient balance"
+    );
 
-    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"
-        );
-      }
-    }
+    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();
+    
+    _storeGlobalPool(globalPoolAmount);
+    
+    _applyReferralReward(directReferrer, referralReward);
 
-    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);
+    
+    gnetERC20.burn(burnAmount);
 
+    _safeMint(msg.sender, tokenId);
+    
+    emit Buy(msg.sender, tokenId);
     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 {
@@ -291,15 +286,22 @@ contract NFT is
     );
   }
 
+  function _applyReferralReward(address directReferrer, uint referralReward) private {
+    if (directReferrer != address(0) && referralReward > 0) {
+      rewardMap[directReferrer] += referralReward;
+      referralRewardMap[directReferrer] += referralReward;
+    }
+  }
+
   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());
+    uint halfTax = tax / 2;
+    gnetERC20.mintForFarm(halfTax, valhalla.feeReceiverAddress());
+    gnetERC20.mintForFarm(halfTax, valhalla.feeReceiverAddress2());
     gnetERC20.mintForFarm(reward - tax, msg.sender);
 
     Rank rank;
@@ -384,7 +386,7 @@ contract NFT is
       distribution = superLegendRankDistribution;
       base = (globalPool.claimable * 34) / 100;
     }
-
+    if (distribution == 0) return 0;
     return base / distribution;
   }
 
@@ -407,13 +409,11 @@ contract NFT is
 
     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"
-        );
-      }
+    if (rank != Rank.NoRank) {
+      require(
+        nftValue >= eligValue[uint(rank)] * 10 ** gnetERC20.decimals(),
+        "Not Eligible"
+      );
     }
 
     uint tax = (myReward * 10) / 100;

package/contracts/Network.sol

@@ -144,7 +144,7 @@ contract Network is
     // for the sake of gas optimization
     if (_account.rank == Rank.SuperLegend) return;
 
-    if (_account.downlineCount >= 64000 && _account.rank == Rank.Legend) {
+    if (_account.downlineCount >= 200000 && _account.rank == Rank.Legend) {
       uint totalEligibleDirectRank = directLegendRankMap[_address] +
         directSuperLegendRankMap[_address];
 
@@ -155,7 +155,7 @@ contract Network is
         directLegendRankMap[_account.referrer] -= 1;
         directSuperLegendRankMap[_account.referrer] += 1;
       }
-    } else if (_account.downlineCount >= 16000 && _account.rank == Rank.Epic) {
+    } else if (_account.downlineCount >= 50000 && _account.rank == Rank.Epic) {
       uint totalEligibleDirectRank = directEpicRankMap[_address] +
         directLegendRankMap[_address] +
         directSuperLegendRankMap[_address];
@@ -168,7 +168,7 @@ contract Network is
         directLegendRankMap[_account.referrer] += 1;
       }
     } else if (
-      _account.downlineCount >= 6400 && _account.rank == Rank.SuperRare
+      _account.downlineCount >= 10000 && _account.rank == Rank.SuperRare
     ) {
       uint totalEligibleDirectRank = directSuperRareRankMap[_address] +
         directEpicRankMap[_address] +
@@ -182,7 +182,7 @@ contract Network is
         directSuperRareRankMap[_account.referrer] -= 1;
         directEpicRankMap[_account.referrer] += 1;
       }
-    } else if (_account.downlineCount >= 1600 && _account.rank == Rank.Rare) {
+    } else if (_account.downlineCount >= 2000 && _account.rank == Rank.Rare) {
       uint totalEligibleDirectRank = directRareRankMap[_address] +
         directSuperRareRankMap[_address] +
         directEpicRankMap[_address] +

package/contracts/Swap.sol

@@ -19,29 +19,35 @@ contract Swap is Initializable, OwnableUpgradeable, UUPSUpgradeable {
     address _user,
     uint _timeStamp
   );
+  
+  event AddLiquidity(
+    ERC20 indexed token,
+    uint amount,
+    uint timestamp
+  );
+  
+  event RemoveLiquidity(
+    ERC20 indexed token,
+    uint amount,
+    uint timestamp
+  );
 
   ERC20 public usdt;
   ERC20 public cusdt;
   ERC20 public crowd;
-  address public feeReceiver;
-  address public feeMarketing;
 
   function initialize(
     ERC20 _usdt,
     ERC20 _cusdt,
-    ERC20 _crowd,
-    address _feeReceiver,
-    address _feeMarketing
+    ERC20 _crowd
   ) public initializer {
     __Ownable_init();
     __UUPSUpgradeable_init();
     usdt = _usdt;
     cusdt = _cusdt;
     crowd = _crowd;
-    feeReceiver = _feeReceiver;
-    feeMarketing = _feeMarketing;
   }
-
+  
   function swapToCUSDT(uint _amount) public {
     // USDT has 18 decimals. CUSDT has 18 decimals.
     // 1:1 ratio.
@@ -64,23 +70,104 @@ contract Swap is Initializable, OwnableUpgradeable, UUPSUpgradeable {
     crowd.transfer(msg.sender, crowdAmount);
     emit SwapToken(usdt, crowd, _amount, msg.sender, block.timestamp);
   }
+  
+  /**
+   * @notice Owner adds CUSDT liquidity to the pool
+   * @param _amount Amount of CUSDT to add
+   */
+  function addLiquidityCUSDT(uint _amount) public onlyOwner {
+    require(_amount > 0, "Amount must be greater than 0");
+    
+    cusdt.transferFrom(msg.sender, address(this), _amount);
+    
+    emit AddLiquidity(cusdt, _amount, block.timestamp);
+  }
+
+  /**
+   * @notice Owner adds CROWD liquidity to the pool
+   * @param _amount Amount of CROWD to add
+   */
+  function addLiquidityCROWD(uint _amount) public onlyOwner {
+    require(_amount > 0, "Amount must be greater than 0");
+    
+    crowd.transferFrom(msg.sender, address(this), _amount);
+    
+    emit AddLiquidity(crowd, _amount, block.timestamp);
+  }
 
-  function withdrawCUSDT(uint _amount) public onlyOwner {
-    require(cusdt.balanceOf(address(this)) >= _amount, "Insufficient Pool");
+  /**
+   * @notice Owner removes CUSDT liquidity from the pool
+   * @param _amount Amount of CUSDT to remove
+   */
+  function removeLiquidityCUSDT(uint _amount) public onlyOwner {
+    require(_amount > 0, "Amount must be greater than 0");
+    require(cusdt.balanceOf(address(this)) >= _amount, "Insufficient pool balance");
+    
     cusdt.transfer(msg.sender, _amount);
+    
+    emit RemoveLiquidity(cusdt, _amount, block.timestamp);
   }
 
-  function withdrawCROWD(uint _amount) public onlyOwner {
-    require(crowd.balanceOf(address(this)) >= _amount, "Insufficient Pool");
+  /**
+   * @notice Owner removes CROWD liquidity from the pool
+   * @param _amount Amount of CROWD to remove
+   */
+  function removeLiquidityCROWD(uint _amount) public onlyOwner {
+    require(_amount > 0, "Amount must be greater than 0");
+    require(crowd.balanceOf(address(this)) >= _amount, "Insufficient pool balance");
+    
     crowd.transfer(msg.sender, _amount);
+    
+    emit RemoveLiquidity(crowd, _amount, block.timestamp);
   }
 
+  /**
+   * @notice Owner removes USDT from the pool (accumulated from swaps)
+   * @param _amount Amount of USDT to remove
+   */
   function withdrawUSDT(uint _amount) public onlyOwner {
-    require(usdt.balanceOf(address(this)) >= _amount, "Insufficient Pool");
+    require(_amount > 0, "Amount must be greater than 0");
+    require(usdt.balanceOf(address(this)) >= _amount, "Insufficient pool balance");
+    
     usdt.transfer(msg.sender, _amount);
   }
+  
+  /**
+   * @notice Get pool balances for all tokens
+   */
+  function getPoolBalances() public view returns (
+    uint usdtBalance, 
+    uint cusdtBalance, 
+    uint crowdBalance
+  ) {
+    return (
+      usdt.balanceOf(address(this)),
+      cusdt.balanceOf(address(this)),
+      crowd.balanceOf(address(this))
+    );
+  }
+
+  /**
+   * @notice Get CUSDT exchange rate
+   * @dev Returns how much CUSDT you get per 1 USDT (with 18 decimals)
+   * @return cusdtRate The amount of CUSDT per 1 USDT (1:1 ratio = 1e18)
+   */
+  function getCusdtRate() public pure returns (uint cusdtRate) {
+    // 1 USDT = 1 CUSDT (1:1 ratio)
+    return 1e18; // 1 USDT (18 decimals) = 1 CUSDT (18 decimals)
+  }
+
+  /**
+   * @notice Get CROWD exchange rate
+   * @dev Returns how much CROWD you get per 1 USDT (with 18 decimals)
+   * @return crowdRate The amount of CROWD per 1 USDT (500 CROWD per USDT = 500e18)
+   */
+  function getCrowdRate() public pure returns (uint crowdRate) {
+    // 1 USDT = 500 CROWD (or 1 CROWD = 0.002 USDT)
+    return 500e18; // 1 USDT (18 decimals) = 500 CROWD (18 decimals)
+  }
 
   function _authorizeUpgrade(
     address newImplementation
   ) internal override onlyOwner {}
-}
+}

package/contracts/USDT.sol

@@ -9,8 +9,8 @@ contract USDT is ERC20, ERC20Burnable, Ownable {
   address public minterContract;
 
   // this is not real name, please check the contract first before deploying !
-  constructor() ERC20("United State Dolar", "USDT") {
-    _mint(msg.sender, 1_000_000_000 * 10 ** 18);
+  constructor() ERC20("United States Dollar", "USDT") {
+    _mint(msg.sender, 1_000_000 * 10 ** 18);
   }
 
   function decimals() public pure override returns (uint8) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gn-contracts",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "main": "index.js",
   "scripts": {