nodara-contract 1.0.0

package/contracts/NFTFounder.sol

@@ -0,0 +1,254 @@
+// 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/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
+
+import "./USDT.sol";
+import "./lib/NFTGetter.sol";
+import "./NFT.sol";
+import "./Network.sol";
+
+contract NFTFounder is
+  Initializable,
+  ERC721Upgradeable,
+  OwnableUpgradeable,
+  ERC721EnumerableUpgradeable,
+  ERC721URIStorageUpgradeable,
+  UUPSUpgradeable
+{
+  using CountersUpgradeable for CountersUpgradeable.Counter;
+
+  CountersUpgradeable.Counter private _tokenIdCounter;
+  CountersUpgradeable.Counter private _cardIdCounter;
+  USDT public usdtERC20;
+  Network public valhalla;
+
+  CardFounder public cardFounder;
+  mapping(address => CardsRewardFounder) public nftFounder;
+  uint public nftFounderPoolMarker;
+  address public receiverAddress;
+  address public receiverAddress2;
+  uint256 public nftFounderPool;
+
+  // events
+  event BuyNFTs(address indexed _from, uint[] _tokenIds);
+  event ClaimReward(address indexed _from, uint value);
+  event DistributeRewards(address indexed from, uint value);
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor() {
+    _disableInitializers();
+  }
+
+  function initialize(
+    USDT _usdtERC20,
+    Network _valhalla,
+    address _receiver
+  ) public initializer {
+    __ERC721_init("NFTFounder", "NFTF");
+    __ERC721Enumerable_init();
+    __Ownable_init();
+    __UUPSUpgradeable_init();
+    valhalla = _valhalla;
+    receiverAddress = _receiver;
+    usdtERC20 = _usdtERC20;
+
+    cardFounder.totalMinted = 0;
+    _cardIdCounter.increment();
+  }
+
+  modifier onlyValhalla() {
+    require(msg.sender == address(valhalla), "Only Admin can perform action");
+    _;
+  }
+
+  function setFounderProps(uint _price, uint _maxMinted) public {
+    cardFounder.price = _price * 10 ** usdtERC20.decimals();
+    cardFounder.maxMinted = _maxMinted;
+  }
+
+  function myNftRewards(address _address) public view returns (uint) {
+    CardsRewardFounder memory nftCards = nftFounder[_address];
+    uint poolMarker = nftFounderPoolMarker;
+
+    if (!(poolMarker > nftCards.currentRewards)) return 0;
+    return (poolMarker - nftCards.currentRewards) * nftCards.ownedNfts;
+  }
+
+  function buyNFTs(uint amount) public {
+    bool isRegistered;
+    address referrer;
+    (isRegistered, , , referrer, , , , ) = valhalla.accountMap(msg.sender);
+
+    uint8[3] memory distributedValue = [5, 3, 2];
+
+    require(isRegistered, "Not registered yet");
+
+    uint[] memory tokenIds = new uint[](amount);
+    // usdtERC20.transferFrom(msg.sender, receiverAddress, cardFounder.price * amount);
+
+    require(
+      cardFounder.maxMinted >= cardFounder.totalMinted + amount,
+      "Max minted reached"
+    );
+
+    for (uint i = 0; i < 3; i++) {
+      if (referrer == address(0)) {
+        usdtERC20.transferFrom(
+          msg.sender,
+          receiverAddress,
+          (distributedValue[i] * cardFounder.price * amount) / 100
+        );
+      } else {
+        usdtERC20.transferFrom(
+          msg.sender,
+          referrer,
+          (distributedValue[i] * cardFounder.price * amount) / 100
+        );
+        (, , , referrer, , , , ) = valhalla.accountMap(referrer);
+      }
+    }
+
+    usdtERC20.transferFrom(
+      msg.sender,
+      receiverAddress,
+      ((36 * cardFounder.price) / 100) * amount
+    );
+    usdtERC20.transferFrom(
+      msg.sender,
+      receiverAddress2,
+      ((54 * cardFounder.price) / 100) * amount
+    );
+
+    for (uint i = 0; i < amount; i++) {
+      uint256 tokenId = _tokenIdCounter.current();
+      tokenIds[i] = tokenId;
+      _tokenIdCounter.increment();
+      _safeMint(msg.sender, tokenId);
+    }
+
+    uint rewards = myNftRewards(msg.sender);
+    if (rewards > 0) claimRewards();
+
+    CardsRewardFounder storage nftCards = nftFounder[msg.sender];
+    nftCards.ownedNfts += amount;
+    cardFounder.totalMinted += amount;
+    nftCards.currentRewards = nftFounderPoolMarker;
+
+    emit BuyNFTs(msg.sender, tokenIds);
+  }
+
+  function claimRewards() public {
+    uint rewards = myNftRewards(msg.sender);
+    require(rewards > 0, "No rewards yet");
+
+    CardsRewardFounder storage nftCards = nftFounder[msg.sender];
+    nftCards.currentRewards = nftFounderPoolMarker;
+    nftFounderPool -= rewards;
+
+    usdtERC20.transfer(msg.sender, rewards);
+    emit ClaimReward(msg.sender, rewards);
+  }
+
+  function setReceiverAddress2(address _receiver) public onlyOwner {
+    receiverAddress2 = _receiver;
+  }
+
+  function distributeFounderRewards(uint value) external onlyValhalla {
+    // Always add value to pool so it's tracked
+    nftFounderPool += value;
+    
+    // Only distribute per-NFT rewards if NFTs have been minted
+    // This prevents division by zero and accumulates rewards for future distribution
+    if (cardFounder.totalMinted == 0) return;
+    
+    nftFounderPoolMarker += value / cardFounder.totalMinted;
+  }
+
+  function safeMint(address to) public onlyOwner {
+    uint256 tokenId = _tokenIdCounter.current();
+    _tokenIdCounter.increment();
+    _safeMint(to, tokenId);
+  }
+
+  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 _burn(
+    uint256 tokenId
+  ) internal override(ERC721Upgradeable, ERC721URIStorageUpgradeable) {
+    super._burn(tokenId);
+  }
+
+  function tokenURI(
+    uint256 tokenId
+  )
+    public
+    view
+    override(ERC721Upgradeable, ERC721URIStorageUpgradeable)
+    returns (string memory)
+  {
+    return super.tokenURI(tokenId);
+  }
+
+  function supportsInterface(
+    bytes4 interfaceId
+  )
+    public
+    view
+    override(
+      ERC721EnumerableUpgradeable,
+      ERC721URIStorageUpgradeable,
+      ERC721Upgradeable
+    )
+    returns (bool)
+  {
+    return super.supportsInterface(interfaceId);
+  }
+
+  function _baseURI() internal pure override returns (string memory) {
+    return "https://crowdstrike.club/api/image/founder/";
+  }
+
+  function transferFrom(
+    address from,
+    address to,
+    uint256 tokenId
+  ) public override(ERC721Upgradeable, IERC721Upgradeable) {
+    super.transferFrom(from, to, tokenId);
+
+    CardsRewardFounder storage cardSender = nftFounder[from];
+
+    uint rewards = myNftRewards(from);
+    if (rewards > 0) {
+      cardSender.currentRewards = nftFounderPoolMarker;
+      nftFounderPool -= rewards;
+      usdtERC20.transfer(msg.sender, rewards);
+    }
+
+    require(cardSender.ownedNfts > 0, "no card left");
+    cardSender.ownedNfts -= 1;
+    CardsRewardFounder storage cardReceiver = nftFounder[to];
+    cardReceiver.ownedNfts += 1;
+    cardReceiver.currentRewards = nftFounderPoolMarker;
+  }
+}

package/contracts/NFTGenesis.sol

@@ -0,0 +1,343 @@
+// 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/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
+import "./lib/NFTGetter.sol";
+import "./NFT.sol";
+import "./CROWD.sol";
+import "./CUSDT.sol";
+import "./Network.sol";
+
+contract NFTGenesis is
+  Initializable,
+  ERC721Upgradeable,
+  OwnableUpgradeable,
+  ERC721EnumerableUpgradeable,
+  ERC721URIStorageUpgradeable,
+  UUPSUpgradeable,
+  ReentrancyGuardUpgradeable
+{
+  using CountersUpgradeable for CountersUpgradeable.Counter;
+  using StringsUpgradeable for uint256;
+
+  CountersUpgradeable.Counter private _tokenIdCounter;
+  CountersUpgradeable.Counter private _cardIdCounter;
+  CROWD public gnetERC20;
+  CUSDT public usdtERC20;
+  Network public valhalla;
+  NFT valhallaNFT;
+
+  // define token id
+  mapping(uint => uint) public tokenIdToCardId;
+  mapping(uint => CardGenesis) public cardMap;
+  // address -> nftType -> flagRewards
+  mapping(address => mapping(uint => CardsRewardGenesis)) public nftGenesis;
+  // nftType -> poolMarker
+  mapping(uint => uint) public nftGenesisPoolMarker;
+  mapping(address => uint) public genesisReferralRewardMap;
+  address public receiverAddress;
+  uint256 public nftGenesisPool;
+
+  // events
+  event BuyMultipleNFT(address indexed _from, uint[] _tokenIds);
+  event ClaimReward(address indexed _from, uint value);
+  event DistributeRewards(address indexed from, uint value);
+  event GenesisReferralReward(
+    address indexed referrer,
+    address indexed buyer,
+    uint value
+  );
+  event GenesisClaimReferralReward(address indexed referrer, uint value);
+  event NFTTypeAdded(
+    uint indexed cardId,
+    uint price,
+    uint percentage,
+    uint maxMinted
+  );
+  event GenesisPoolDistributed(
+    uint indexed typePool,
+    uint value,
+    uint newMarker
+  );
+  event ReceiverAddressUpdated(
+    address indexed oldReceiver,
+    address indexed newReceiver,
+    uint256 timestamp
+  );
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor() {
+    _disableInitializers();
+  }
+
+  function initialize(
+    CROWD _gnetERC20,
+    CUSDT _usdtERC20,
+    NFT _valhallaNFT,
+    Network _valhalla,
+    address _receiver
+  ) public initializer {
+    require(address(_gnetERC20) != address(0), "Invalid GNET address");
+    require(address(_usdtERC20) != address(0), "Invalid USDT address");
+    require(address(_valhallaNFT) != address(0), "Invalid NFT address");
+    require(address(_valhalla) != address(0), "Invalid Network address");
+    require(_receiver != address(0), "Invalid receiver address");
+
+    __ERC721_init("NFTGenesis", "NFTG");
+    __ERC721Enumerable_init();
+    __ERC721URIStorage_init();
+    __Ownable_init();
+    __UUPSUpgradeable_init();
+    __ReentrancyGuard_init();
+    gnetERC20 = _gnetERC20;
+    valhallaNFT = _valhallaNFT;
+    receiverAddress = _receiver;
+    usdtERC20 = _usdtERC20;
+    valhalla = _valhalla;
+  }
+
+  modifier onlyValhallaNFT() {
+    require(
+      msg.sender == address(valhallaNFT),
+      "Only Admin can perform action"
+    );
+    _;
+  }
+
+  function amountNftTypes() public view returns (uint) {
+    return _cardIdCounter.current();
+  }
+
+  function percentageByNftType(uint nftType) public view returns (uint) {
+    return cardMap[nftType].genesisPercentage;
+  }
+
+  function addNft(
+    uint _price,
+    uint _percentage,
+    uint _maxMinted
+  ) public onlyOwner {
+    require(_price > 0, "Price must be greater than 0");
+    require(_percentage > 0 && _percentage <= 100, "Invalid percentage");
+    require(_maxMinted > 0, "Max minted must be greater than 0");
+
+    uint _cardId = _cardIdCounter.current();
+    CardGenesis storage _card = cardMap[_cardId];
+    _card.price = _price * 10 ** usdtERC20.decimals();
+    _card.genesisPercentage = _percentage;
+    _card.totalMinted = 0;
+    _card.maxMinted = _maxMinted;
+    _cardIdCounter.increment();
+
+    emit NFTTypeAdded(_cardId, _card.price, _percentage, _maxMinted);
+  }
+
+  function myNftRewards(
+    uint cardId,
+    address _address
+  ) public view returns (uint) {
+    CardsRewardGenesis memory nftCards = nftGenesis[_address][cardId];
+    uint poolMarker = nftGenesisPoolMarker[cardId];
+
+    if (!(poolMarker > nftCards.currentRewards)) return 0;
+    return (poolMarker - nftCards.currentRewards) * nftCards.ownedNfts;
+  }
+
+  function buyMultipleNFT(uint cardId, uint amount) public nonReentrant {
+    CardGenesis storage _card = cardMap[cardId];
+    require(_card.maxMinted > _card.totalMinted + amount, "Max minted reached");
+
+    bool isRegistered;
+    address referrer;
+    (isRegistered, , , referrer, , , , ) = valhalla.accountMap(msg.sender);
+    require(isRegistered, "Registration required");
+
+    uint totalPrice = _card.price * amount;
+    uint commission = (totalPrice * 10) / 100;
+    uint toReceiver = totalPrice - commission;
+    uint rewards = myNftRewards(cardId, msg.sender);
+
+    CardsRewardGenesis storage nftCards = nftGenesis[msg.sender][cardId];
+    nftCards.ownedNfts += amount;
+    _card.totalMinted += amount;
+    nftCards.currentRewards = nftGenesisPoolMarker[cardId];
+
+    uint[] memory tokenIds = new uint[](amount);
+    for (uint i = 0; i < amount; i++) {
+      uint256 tokenId = _tokenIdCounter.current();
+      tokenIds[i] = tokenId;
+      tokenIdToCardId[tokenId] = cardId;
+      _tokenIdCounter.increment();
+    }
+
+    usdtERC20.transferFrom(msg.sender, address(this), totalPrice);
+    usdtERC20.transfer(receiverAddress, toReceiver);
+
+    if (referrer != address(0)) {
+      genesisReferralRewardMap[referrer] += commission;
+      emit GenesisReferralReward(referrer, msg.sender, commission);
+    } else {
+      usdtERC20.transfer(receiverAddress, commission);
+    }
+
+    for (uint i = 0; i < amount; i++) {
+      _safeMint(msg.sender, tokenIds[i]);
+      _setTokenURI(tokenIds[i], cardId.toString());
+    }
+
+    if (rewards > 0) _distributeReward(msg.sender, rewards);
+
+    emit BuyMultipleNFT(msg.sender, tokenIds);
+  }
+
+  function claimRewards(uint cardId) public nonReentrant {
+    uint rewards = myNftRewards(cardId, msg.sender);
+    require(rewards > 0, "No rewards yet");
+
+    CardsRewardGenesis storage nftCards = nftGenesis[msg.sender][cardId];
+    nftCards.currentRewards = nftGenesisPoolMarker[cardId];
+
+    _distributeReward(msg.sender, rewards);
+  }
+
+  function _distributeReward(address to, uint amount) private {
+    require(nftGenesisPool >= amount, "Insufficient pool balance");
+    nftGenesisPool -= amount;
+    gnetERC20.transfer(to, amount);
+    emit ClaimReward(to, amount);
+  }
+
+  function claimReferralReward() public nonReentrant {
+    uint reward = genesisReferralRewardMap[msg.sender];
+    require(reward > 0, "No referral reward to claim");
+
+    genesisReferralRewardMap[msg.sender] = 0;
+    usdtERC20.transfer(msg.sender, reward);
+
+    emit GenesisClaimReferralReward(msg.sender, reward);
+  }
+
+  function distributeGenesisRewards(
+    uint typePool,
+    uint value
+  ) external onlyValhallaNFT {
+    uint totalMinted = cardMap[typePool].totalMinted;
+    require(totalMinted > 0, "No NFTs minted for this type");
+
+    uint perNftReward = value / totalMinted;
+    nftGenesisPoolMarker[typePool] += perNftReward;
+    nftGenesisPool += value;
+
+    emit GenesisPoolDistributed(
+      typePool,
+      value,
+      nftGenesisPoolMarker[typePool]
+    );
+  }
+
+  function _baseURI() internal pure override returns (string memory) {
+    return "https://crowdstrike.club/api/image/genesis/";
+  }
+
+  function safeMint(address to) public onlyOwner {
+    uint256 tokenId = _tokenIdCounter.current();
+    _tokenIdCounter.increment();
+    _safeMint(to, tokenId);
+  }
+
+  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 _burn(
+    uint256 tokenId
+  ) internal override(ERC721Upgradeable, ERC721URIStorageUpgradeable) {
+    super._burn(tokenId);
+  }
+
+  function tokenURI(
+    uint256 tokenId
+  )
+    public
+    view
+    override(ERC721Upgradeable, ERC721URIStorageUpgradeable)
+    returns (string memory)
+  {
+    return super.tokenURI(tokenId);
+  }
+
+  function transferFrom(
+    address from,
+    address to,
+    uint256 tokenId
+  ) public override(ERC721Upgradeable, IERC721Upgradeable) nonReentrant {
+    // Get card info and calculate rewards before any state changes
+    uint cardId = tokenIdToCardId[tokenId];
+    CardsRewardGenesis storage cardSender = nftGenesis[from][cardId];
+    uint rewards = myNftRewards(cardId, from);
+
+    // Update state for sender
+    if (rewards > 0) {
+      cardSender.currentRewards = nftGenesisPoolMarker[cardId];
+      nftGenesisPool -= rewards;
+    }
+
+    require(cardSender.ownedNfts > 0, "no card left");
+    cardSender.ownedNfts -= 1;
+
+    // Update state for receiver
+    CardsRewardGenesis storage cardReceiver = nftGenesis[to][cardId];
+    cardReceiver.ownedNfts += 1;
+    cardReceiver.currentRewards = nftGenesisPoolMarker[cardId];
+
+    // External calls last
+    if (rewards > 0) {
+      gnetERC20.transfer(from, rewards); // Send to 'from', not msg.sender
+    }
+
+    super.transferFrom(from, to, tokenId);
+  }
+
+  function supportsInterface(
+    bytes4 interfaceId
+  )
+    public
+    view
+    override(
+      ERC721EnumerableUpgradeable,
+      ERC721URIStorageUpgradeable,
+      ERC721Upgradeable
+    )
+    returns (bool)
+  {
+    return super.supportsInterface(interfaceId);
+  }
+
+  function setReceiverAddress(address _receiver) public onlyOwner {
+    require(_receiver != address(0), "Receiver cannot be zero address");
+
+    address oldReceiver = receiverAddress;
+    receiverAddress = _receiver;
+
+    emit ReceiverAddressUpdated(oldReceiver, _receiver, block.timestamp);
+  }
+}