nodara-contract 1.0.0

package/contracts/USDT.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 USDT is ERC20, ERC20Burnable, Ownable {
+  address public minterContract;
+
+  // this is not real name, please check the contract first before deploying !
+  constructor() ERC20("United States Dollar", "USDT") {
+    _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/lib/AccessControl.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+
+abstract contract AccessControl is AccessControlUpgradeable {
+    // role definition
+    bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
+    bytes32 public constant STAFF_ROLE = keccak256("STAFF_ROLE");
+
+    modifier onlyAdmin() {
+        require(
+            hasRole(DEFAULT_ADMIN_ROLE, msg.sender),
+            "Only Admin can perform action"
+        );
+        _;
+    }
+
+    modifier onlyUpgrader() {
+        require(
+            hasRole(UPGRADER_ROLE, msg.sender),
+            "Only UPGRADER can perform action"
+        );
+        _;
+    }
+
+    modifier onlyStaff() {
+        require(
+            hasRole(DEFAULT_ADMIN_ROLE, msg.sender) ||
+                hasRole(STAFF_ROLE, msg.sender),
+            "Only Admin can perform action"
+        );
+        _;
+    }
+}

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/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "nodara-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/better-sqlite3": "^7.6.13",
+    "@types/chai": "^4.3.4",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.11.9",
+    "better-sqlite3": "^12.6.2",
+    "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"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "artifacts",
+    "typechain-types",
+    "contracts",
+    "constant"
+  ],
+  "release": {
+    "branches": [
+      "main"
+    ]
+  },
+  "volta": {
+    "node": "18.16.0"
+  }
+}

package/typechain-types/@openzeppelin/contracts/access/Ownable.ts

@@ -0,0 +1,176 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface OwnableInterface extends utils.Interface {
+  functions: {
+    "owner()": FunctionFragment;
+    "renounceOwnership()": FunctionFragment;
+    "transferOwnership(address)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "owner" | "renounceOwnership" | "transferOwnership"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "renounceOwnership",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferOwnership",
+    values: [PromiseOrValue<string>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "renounceOwnership",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "transferOwnership",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "OwnershipTransferred(address,address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+}
+
+export interface OwnershipTransferredEventObject {
+  previousOwner: string;
+  newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<
+  [string, string],
+  OwnershipTransferredEventObject
+>;
+
+export type OwnershipTransferredEventFilter =
+  TypedEventFilter<OwnershipTransferredEvent>;
+
+export interface Ownable extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: OwnableInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    owner(overrides?: CallOverrides): Promise<[string]>;
+
+    renounceOwnership(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    transferOwnership(
+      newOwner: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  owner(overrides?: CallOverrides): Promise<string>;
+
+  renounceOwnership(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  transferOwnership(
+    newOwner: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    owner(overrides?: CallOverrides): Promise<string>;
+
+    renounceOwnership(overrides?: CallOverrides): Promise<void>;
+
+    transferOwnership(
+      newOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "OwnershipTransferred(address,address)"(
+      previousOwner?: PromiseOrValue<string> | null,
+      newOwner?: PromiseOrValue<string> | null
+    ): OwnershipTransferredEventFilter;
+    OwnershipTransferred(
+      previousOwner?: PromiseOrValue<string> | null,
+      newOwner?: PromiseOrValue<string> | null
+    ): OwnershipTransferredEventFilter;
+  };
+
+  estimateGas: {
+    owner(overrides?: CallOverrides): Promise<BigNumber>;
+
+    renounceOwnership(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    transferOwnership(
+      newOwner: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    renounceOwnership(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferOwnership(
+      newOwner: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/typechain-types/@openzeppelin/contracts/access/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { Ownable } from "./Ownable";

package/typechain-types/@openzeppelin/contracts/index.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as access from "./access";
+export type { access };
+import type * as token from "./token";
+export type { token };