gn-contract 1.0.0

package/contracts/lib/NFTGetter.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "./ValhallaPool.sol";
+
+struct Card {
+    bool isMintable;
+    uint price;
+    uint halfingPercentage;
+}
+
+struct CardGenesis {
+    uint price;
+    uint genesisPercentage;
+    uint totalMinted;
+    uint maxMinted;
+}
+
+struct CardsRewardGenesis {
+    uint ownedNfts;
+    uint currentRewards;
+}
+
+struct CardFounder {
+    uint price;
+    uint totalMinted;
+    uint maxMinted;
+}
+
+struct CardsRewardFounder {
+    uint ownedNfts;
+    uint currentRewards;
+}
+
+struct OwnedToken {
+    bool isBlackListed;
+    uint cardId;
+    uint percentage;
+    uint lastFarmedAt;
+    uint mintedAt;
+    uint mintingPrice;
+}
+
+contract NFTGetter {
+    mapping(uint => OwnedToken) public tokenToCardMap;
+    mapping(uint => Card) public cardMap;
+    mapping(address => uint) public totalValueMap;
+    mapping(address => uint) public farmReward;
+
+    function startClaimingRankReward() external {}
+
+    function stopClaimingRankReward() external {}
+
+    function amountNftTypes() external view returns (uint) {}
+
+    function percentageByNftType(uint nftType) external view returns (uint) {}
+
+    function distributeGenesisRewards(uint typePool, uint value) external {}
+
+}

package/contracts/lib/NFTHelpers.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+library NFTHelpers {
+  function getRandomFarmPercentage(
+    uint256 rand
+  ) internal pure returns (uint256) {
+    if (rand >= 0 && rand <= 699) {
+      return 5;
+    }
+    if (rand > 699 && rand <= 900) {
+      return 6;
+    }
+    if (rand > 900 && rand <= 991) {
+      return 7;
+    }
+    if (rand > 991 && rand <= 996) {
+      return 8;
+    }
+    if (rand > 996 && rand <= 998) {
+      return 10;
+    }
+    if (rand == 999) {
+      return 15;
+    }
+    return 8;
+  }
+
+  function calculateFarmValue(
+    uint mintedAt,
+    uint lastFarmedAt,
+    uint percentage,
+    uint price,
+    uint halfingPercentage
+  ) internal view returns (uint256) {
+    uint dayInSec = 86400;
+    if (block.timestamp > mintedAt + dayInSec * 450) return 0;
+
+    uint baseReward = (price * percentage) / 1000;
+    uint rewardPerSec = baseReward / dayInSec;
+    uint farmValue = (block.timestamp - lastFarmedAt) * rewardPerSec;
+    return (farmValue * halfingPercentage) / 100;
+  }
+
+  function getReferrerMatchingPercentage(
+    uint level,
+    uint8 rank,
+    uint totalValue,
+    uint decimals
+  ) internal pure returns (uint) {
+    if (level >= 1 && level <= 5 && totalValue >= 5000 * 10 ** decimals) {
+      return 5;
+    }
+
+    if (
+      level >= 6 &&
+      level <= 10 &&
+      rank >= 1 &&
+      totalValue >= 25_000 * 10 ** decimals
+    ) {
+      return 1;
+    }
+
+    if (
+      level >= 11 &&
+      level <= 20 &&
+      rank >= 2 &&
+      totalValue >= 100_000 * 10 ** decimals
+    ) {
+      return 1;
+    }
+
+    if (
+      level >= 21 &&
+      level <= 40 &&
+      rank >= 3 &&
+      totalValue >= 500_000 * 10 ** decimals
+    ) {
+      return 1;
+    }
+
+    if (
+      level >= 41 &&
+      level <= 60 &&
+      rank >= 4 &&
+      totalValue >= 2_500_000 * 10 ** decimals
+    ) {
+      return 1;
+    }
+
+    if (
+      level >= 61 &&
+      level <= 80 &&
+      rank >= 5 &&
+      totalValue >= 10_000_000 * 10 ** decimals
+    ) {
+      return 1;
+    }
+
+    if (
+      level >= 81 &&
+      level <= 100 &&
+      rank == 6 &&
+      totalValue >= 50_000_000 * 10 ** decimals
+    ) {
+      return 1;
+    }
+
+    return 0;
+  }
+}

package/contracts/lib/ValhallaBlackList.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+abstract contract ValhallaBlackList {
+    mapping(address => bool) public blacklistedAddressMap;
+
+    modifier notInBlacklist() {
+        require(
+            blacklistedAddressMap[msg.sender] != true,
+            "Address blacklisted"
+        );
+        _;
+    }
+
+    function addToBlacklistMap(address addr) internal {
+        blacklistedAddressMap[addr] = true;
+    }
+}

package/contracts/lib/ValhallaPool.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+struct PoolType {
+    uint claimable;
+    uint valueLeft;
+}
+
+abstract contract ValhallaPool {
+    // pool key definition
+    bytes32 public constant GLOBAL_POOL_KEY = keccak256("GLOBAL_POOL");
+    bytes32 public constant RESERVED_POOL_KEY = keccak256("RESERVED_POOL");
+    bytes32 public constant IPO_POOL_KEY = keccak256("IPO_POOL");
+    bytes32 public constant GENESIS_POOL_KEY = keccak256("GENESIS_POOL");
+
+    mapping(bytes32 => PoolType) public poolMap;
+
+    function _storeGlobalPool(uint value) internal {
+        PoolType storage global_pool = poolMap[GLOBAL_POOL_KEY];
+        global_pool.claimable += value;
+    }
+
+    function getGlobalPool() public view returns (PoolType memory) {
+        return poolMap[GLOBAL_POOL_KEY];
+    }
+
+    function _storeIpoPool(uint value) internal {
+        PoolType storage ipo_pool = poolMap[IPO_POOL_KEY];
+        ipo_pool.claimable += value;
+    }
+
+    function getIpoPool() public view returns (PoolType memory) {
+        return poolMap[IPO_POOL_KEY];
+    }
+
+    function _storeGenesisPool(uint value) internal {
+        PoolType storage genesisPool = poolMap[GENESIS_POOL_KEY];
+        genesisPool.claimable += value;
+    }
+
+    function getGenesisPool() public view returns (PoolType memory) {
+        return poolMap[GENESIS_POOL_KEY];
+    }
+}

package/hardhat.config.ts

@@ -0,0 +1,44 @@
+import * as dotenv from "dotenv";
+
+import { HardhatUserConfig } from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+import "@openzeppelin/hardhat-upgrades";
+
+dotenv.config();
+
+const config: HardhatUserConfig = {
+  solidity: {
+    compilers: [
+      {
+        version: "0.8.17",
+        settings: {
+          optimizer: {
+            enabled: true,
+            runs: 200,
+          },
+        },
+      },
+    ],
+  },
+  defaultNetwork: "hardhat",
+  mocha: {
+    timeout: 100000000,
+  },
+  networks: {
+    testnet: {
+      url: "https://data-seed-prebsc-1-s1.bnbchain.org:8545",
+      accounts: {
+        mnemonic: process.env.MNEMONIC ?? "",
+      },
+      gasPrice: 10000000000,
+    },
+    mainnet: {
+      url: "https://bsc-dataseed.bnbchain.org",
+      accounts: {
+        mnemonic: process.env.MNEMONIC ?? "",
+      },
+    },
+  },
+};
+
+export default config;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "gn-contract",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.20.0",
+  "devDependencies": {
+    "@ethersproject/abi": "^5.7.0",
+    "@ethersproject/bytes": "^5.0.0",
+    "@ethersproject/providers": "^5.7.2",
+    "@nomicfoundation/hardhat-chai-matchers": "^1.0.4",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.6",
+    "@nomicfoundation/hardhat-toolbox": "^2.0.0",
+    "@nomiclabs/hardhat-ethers": "^2.2.1",
+    "@nomiclabs/hardhat-etherscan": "^3.1.2",
+    "@nomiclabs/hardhat-ganache": "^2.0.1",
+    "@typechain/ethers-v5": "^10.1.1",
+    "@typechain/hardhat": "^6.1.4",
+    "@types/chai": "^4.3.4",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.11.9",
+    "chai": "^4.3.7",
+    "ethers": "^5.7.2",
+    "evm-bn": "^1.1.2",
+    "hardhat": "^2.12.2",
+    "hardhat-gas-reporter": "^1.0.9",
+    "prettier": "^3.7.4",
+    "prettier-plugin-solidity": "^2.2.0",
+    "semantic-release": "^19.0.2",
+    "solidity-coverage": "^0.8.2",
+    "ts-node": "^10.9.1",
+    "typechain": "^8.1.1",
+    "typescript": "^4.9.3"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^4.8.0",
+    "@openzeppelin/contracts-upgradeable": "^4.8.0",
+    "@openzeppelin/hardhat-upgrades": "^1.21.0",
+    "dotenv": "^16.0.3"
+  },
+  "volta": {
+    "node": "18.16.0"
+  }
+}

package/scripts/DeployNetwork.ts

@@ -0,0 +1,123 @@
+import { ethers, upgrades } from "hardhat";
+import {
+  feeReceiverAddress,
+  feeReceiverAddress2,
+  reserveAddress,
+  rootAdressList,
+} from "../constants/rootAddress";
+import { getter } from "../constants/getter";
+import { toBn } from "evm-bn";
+
+const main = async () => {
+  const [admin] = await ethers.getSigners();
+  console.log("Deploying contracts with account:", admin.address);
+
+  // 1. Deploy CROWD Token
+  const CROWDContract = await ethers.getContractFactory("CROWD");
+  const crowd = await CROWDContract.connect(admin).deploy();
+  await crowd.connect(admin).deployed();
+  console.log("CROWD deployed to:", crowd.address);
+
+  const CUSDTContract = await ethers.getContractFactory("CUSDT");
+  const cusdt = await CUSDTContract.connect(admin).deploy();
+  await cusdt.connect(admin).deployed();
+  console.log("CUSDT deployed to:", cusdt.address);
+
+  // 2. Deploy Network (Valhalla)
+  const ValhallaContract = await ethers.getContractFactory("Network");
+  const valhalla = (await upgrades.deployProxy(
+    ValhallaContract,
+    [
+      admin.address,
+      rootAdressList,
+      feeReceiverAddress,
+      feeReceiverAddress2,
+      reserveAddress,
+      0,
+      toBn("10", 18), // Registration fee: 50 USDT (18 decimals)
+    ],
+    { kind: "transparent" }
+  )) as any;
+  await valhalla.connect(admin).deployed();
+  console.log("Network (Valhalla) deployed to:", valhalla.address);
+
+  // 3. Deploy NFT
+  const NFTContract = await ethers.getContractFactory("NFT");
+  const nft = (await upgrades.deployProxy(NFTContract, [crowd.address, valhalla.address], {
+    kind: "transparent",
+  })) as any;
+  await nft.connect(admin).deployed();
+  console.log("NFT deployed to:", nft.address);
+
+  // 4. Deploy NFTGenesis
+  // Note: Using a placeholder receiver address if not defined in getter, or use admin
+  const genesisReceiver = admin.address;
+  const NFTGenesiscontract = await ethers.getContractFactory("NFTGenesis");
+  const nftGenesis = (await upgrades.deployProxy(
+    NFTGenesiscontract,
+    [crowd.address, cusdt.address, nft.address, valhalla.address, genesisReceiver],
+    { kind: "transparent" }
+  )) as any;
+  await nftGenesis.connect(admin).deployed();
+  console.log("NFTGenesis deployed to:", nftGenesis.address);
+
+  // 5. Deploy NFTFounder
+  const NFTFounderContract = await ethers.getContractFactory("NFTFounder");
+  const nftFounder = (await upgrades.deployProxy(
+    NFTFounderContract,
+    [
+      getter.usdt.address,
+      valhalla.address,
+      genesisReceiver, // Using same receiver for founder
+    ],
+    { kind: "transparent" }
+  )) as any;
+  await nftFounder.connect(admin).deployed();
+  console.log("NFTFounder deployed to:", nftFounder.address);
+
+  // --- Configuration ---
+
+  console.log("Configuring contracts...");
+
+  const tx = await crowd.setMinterContract(nft.address);
+  await tx.wait();
+  console.log("CROWD minter set to NFT");
+
+  const tx2 = await valhalla.connect(admin).setNftAddress(nft.address);
+  await tx2.wait();
+  console.log("Network NFT address set");
+
+  const tx3 = await valhalla.connect(admin).setCRWDAddress(crowd.address);
+  await tx3.wait();
+  console.log("Network CROWD address set");
+
+  const tx4 = await nft.setNFTGenesis(nftGenesis.address);
+  await tx4.wait();
+  console.log("NFT Genesis address set");
+
+  const tx5 = await valhalla.connect(admin).setCUSDAddress(cusdt.address);
+  await tx5.wait();
+  console.log("Network Payment Token (CUSDT) set");
+
+  const tx6 = await valhalla.connect(admin).setNFTFounderAddress(nftFounder.address);
+  await tx6.wait();
+  console.log("Network NFTFounder address set");
+
+  // Set receiver2 for NFTFounder if needed (optional based on logic)
+  // const tx7 = await nftFounder.setReceiverAddress2(receiverAddress2);
+  // await tx7.wait();
+
+  console.table({
+    valhalla: valhalla.address,
+    nft: nft.address,
+    nftGenesis: nftGenesis.address,
+    nftFounder: nftFounder.address,
+    crowd: crowd.address,
+    cusdt: cusdt.address,
+  });
+};
+
+main().catch((e) => {
+  console.log(e);
+  process.exitCode = 1;
+});

package/scripts/DeploySwap.ts

@@ -0,0 +1,57 @@
+import { ethers, upgrades } from "hardhat";
+import {
+  feeReceiverAddress,
+  feeReceiverAddress2,
+} from "../constants/rootAddress";
+import { getter } from "../constants/getter";
+
+async function main() {
+  const [deployer] = await ethers.getSigners();
+  console.log("Deploying contracts with the account:", deployer.address);
+
+  // 1. Deploy CROWD Token
+  console.log("Deploying CROWD...");
+  const CROWDFactory = await ethers.getContractFactory("CROWD");
+  const crowd = await CROWDFactory.deploy();
+  await crowd.deployed();
+  console.log("CROWD deployed to:", crowd.address);
+
+  // 2. Deploy CUSDT Token
+  console.log("Deploying CUSDT...");
+  const CUSDTFactory = await ethers.getContractFactory("CUSDT");
+  const cusdt = await CUSDTFactory.deploy();
+  await cusdt.deployed();
+  console.log("CUSDT deployed to:", cusdt.address);
+
+  // 3. Deploy Swap Contract
+  console.log("Deploying Swap...");
+  const SwapFactory = await ethers.getContractFactory("Swap");
+  // Arguments: _usdt, _cusdt, _crowd, _feeReceiver, _feeMarketing
+  const swap = await upgrades.deployProxy(
+    SwapFactory,
+    [
+      getter.usdt.address,
+      cusdt.address,
+      crowd.address,
+      feeReceiverAddress,
+      feeReceiverAddress2,
+    ],
+    { kind: "uups" },
+  );
+  await swap.deployed();
+  console.log("Swap deployed to:", swap.address);
+
+  // Verification Log
+  console.table({
+    Deployer: deployer.address,
+    CROWD: crowd.address,
+    CUSDT: cusdt.address,
+    Swap: swap.address,
+    USDT: getter.usdt.address,
+  });
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/DeployUSDT.ts

@@ -0,0 +1,16 @@
+import { ethers, upgrades } from "hardhat";
+
+const main = async () => {
+  const [admin] = await ethers.getSigners();
+  console.log("Deploying contracts with account:", admin.address);
+
+  const USDTContract = await ethers.getContractFactory("USDT");
+  const usdt = await USDTContract.connect(admin).deploy();
+  await usdt.connect(admin).deployed();
+  console.log("USDT deployed at", usdt.address);
+};
+
+main().catch((e) => {
+  console.log(e);
+  process.exitCode = 1;
+});