NodexDeploy

{{
  "language": "Solidity",
  "sources": {
    "nodexlab.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
pragma solidity ^0.8.26;\r
\r
/*\r
 *  NodexLAB.IO (NODEX)\r
 *  https://nodexlab.io/\r
\r
 *  - Supply:      100,000,000 * 10^9 (100M tokens, 9 decimals)\r
 *  - Tax:         Fixed 5% on all non-owner transfers (buys & sells). Non-changeable.\r
 *  - Distribution: 50% Marketing, 50% Development (constructor-set wallets).\r
 *  - Auto-Sell:   Enabled. When contract token pot > 0.5% of supply and after 30 buys,\r
 *                 swaps tokens -> ETH via Uniswap V2 router and, if ETH >= 0.1,\r
 *                 distributes equally to Marketing & Development wallets.\r
 *  - Limits:      MaxTx = 1.5% supply, MaxWallet = 1.5% supply, enforced on BUYS ONLY\r
 *                 during the first 15 minutes after trading is opened.\r
 *  - Liquidity:   You will add liquidity manually via Uniswap UI.\r
 *  - Pair:        Owner sets the pair once created (`setPair(address)`).\r
 *  - Trading:     Owner opens trading time window & enables swaps via `setTradingOpen()`.\r
 *\r
 *  Notes:\r
 *  - Owner is exempt from fees to allow clean LP provisioning and treasury ops.\r
 *  - Manual test helpers: manualSwap(), manualSendETH(amount), manualSendTokens().\r
 */\r
\r
interface IERC20 {\r
    function totalSupply() external view returns (uint256);\r
    function balanceOf(address account) external view returns (uint256);\r
    function allowance(address owner, address spender) external view returns (uint256);\r
    function approve(address spender, uint256 amount) external returns (bool);\r
    function transfer(address recipient, uint256 amount) external returns (bool);\r
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
}\r
\r
abstract contract Ownable {\r
    address private _owner;\r
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r
    constructor() { _owner = msg.sender; emit OwnershipTransferred(address(0), msg.sender); }\r
    function owner() public view returns (address) { return _owner; }\r
    modifier onlyOwner() { require(msg.sender == _owner, "Ownable: caller is not the owner"); _; }\r
    function renounceOwnership() external onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); }\r
}\r
\r
interface IUniswapV2Router02 {\r
    function factory() external pure returns (address);\r
    function WETH() external pure returns (address);\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint amountIn,\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external;\r
}\r
\r
contract NodexDeploy is IERC20, Ownable {\r
    // --- Token data ---\r
    string private constant _NAME   = "NodexLAB.IO";\r
    string private constant _SYMBOL = "NODEX";\r
    uint8  private constant _DECIMALS = 9;\r
    uint256 private constant _SUPPLY = 100_000_000 * 10**_DECIMALS; // 100M\r
\r
    // --- Accounting ---\r
    mapping(address => uint256) private _bal;\r
    mapping(address => mapping(address => uint256)) private _allow;\r
\r
    // --- Fee / distribution ---\r
    uint256 private constant TAX_RATE = 5; // fixed 5%\r
    address payable public marketingWallet;\r
    address payable public developmentWallet;\r
\r
    // --- Auto-sell / thresholds ---\r
    uint256 public constant TAX_SWAP_THRESHOLD = 500_000 * 10**_DECIMALS; // 0.5% of supply\r
    uint256 public constant MIN_BUYS_BEFORE_SWAP = 30;\r
    uint256 public buyCount;\r
    bool    public swapEnabled;\r
\r
    // --- Launch limits (buy-only during first 15 min) ---\r
    uint256 public constant MAX_TX = 1_500_000 * 10**_DECIMALS;     // 1.5%\r
    uint256 public constant MAX_WALLET = 1_500_000 * 10**_DECIMALS; // 1.5%\r
    uint256 public launchTime; // set by setTradingOpen()\r
    mapping(address => bool) public isExcludedFromLimits; // excludes only from early buy caps\r
\r
    // --- DEX Router / Pair ---\r
    IUniswapV2Router02 private immutable _router; // Uniswap V2 router (mainnet)\r
    address public pair;                          // Set once after creating the pair\r
    bool public tradingOpen;                      // gating the early-limit window\r
\r
    // --- Internal swap lock ---\r
    bool private _inSwap;\r
    modifier swapping() { _inSwap = true; _; _inSwap = false; }\r
\r
    // --- Events ---\r
    event TradingOpened(uint256 at);\r
    event PairSet(address pair);\r
    event AutoSwap(uint256 tokensSold, uint256 ethReceived);\r
    event Payout(uint256 totalEth, uint256 halfEach);\r
\r
    constructor(address _marketing, address _development) {\r
        require(_marketing != address(0) && _development != address(0), "wallet=0");\r
        marketingWallet   = payable(_marketing);\r
        developmentWallet = payable(_development);\r
\r
        _bal[msg.sender] = _SUPPLY;\r
        isExcludedFromLimits[msg.sender] = true;\r
        isExcludedFromLimits[address(this)] = true;\r
        isExcludedFromLimits[marketingWallet] = true;\r
        isExcludedFromLimits[developmentWallet] = true;\r
\r
        // Uniswap V2 router (Ethereum mainnet)\r
        _router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r
\r
        emit Transfer(address(0), msg.sender, _SUPPLY);\r
    }\r
\r
    // --- ERC20 ---\r
    function name() external pure returns (string memory) { return _NAME; }\r
    function symbol() external pure returns (string memory) { return _SYMBOL; }\r
    function decimals() external pure returns (uint8) { return _DECIMALS; }\r
    function totalSupply() external pure override returns (uint256) { return _SUPPLY; }\r
    function balanceOf(address account) public view override returns (uint256) { return _bal[account]; }\r
    function allowance(address owner_, address spender) external view override returns (uint256) { return _allow[owner_][spender]; }\r
\r
    function approve(address spender, uint256 amount) public override returns (bool) {\r
        _allow[msg.sender][spender] = amount;\r
        emit Approval(msg.sender, spender, amount);\r
        return true;\r
    }\r
\r
    function transfer(address to, uint256 amount) external override returns (bool) {\r
        _transfer(msg.sender, to, amount);\r
        return true;\r
    }\r
\r
    function transferFrom(address from, address to, uint256 amount) external override returns (bool) {\r
        _transfer(from, to, amount);\r
        uint256 curr = _allow[from][msg.sender];\r
        require(curr >= amount, "allowance");\r
        unchecked { _allow[from][msg.sender] = curr - amount; }\r
        return true;\r
    }\r
\r
    // --- Internal transfer logic ---\r
    function _transfer(address from, address to, uint256 amount) internal {\r
        require(from != address(0) && to != address(0), "zero addr");\r
        require(amount > 0, "amt=0");\r
\r
        uint256 fromBal = _bal[from];\r
        require(fromBal >= amount, "bal");\r
\r
        // Fee applies when neither side is owner and not in internal swap\r
        uint256 tax = 0;\r
        if (!_inSwap && from != owner() && to != owner()) {\r
            tax = (amount * TAX_RATE) / 100;\r
        }\r
\r
        // Early buy caps: buys only, first 15 minutes after trading open\r
        if (tradingOpen && launchTime != 0 && from == pair && to != address(_router) && !isExcludedFromLimits[to]) {\r
            if (block.timestamp < launchTime + 15 minutes) {\r
                require(amount <= MAX_TX, "maxTx");\r
                require(_bal[to] + (amount - tax) <= MAX_WALLET, "maxWallet");\r
            }\r
            buyCount += 1;\r
        }\r
\r
        // Auto-sell on sells/transfers (i.e., when from != pair) once thresholds met\r
        if (from != pair && !_inSwap && swapEnabled) {\r
            uint256 pot = _bal[address(this)];\r
            if (pot > TAX_SWAP_THRESHOLD && buyCount > MIN_BUYS_BEFORE_SWAP) {\r
                _swapTokensForETH(pot);\r
                uint256 ethBal = address(this).balance;\r
                if (ethBal >= 0.1 ether) {\r
                    _payout(ethBal);\r
                }\r
            }\r
        }\r
\r
        unchecked {\r
            _bal[from] = fromBal - amount;\r
            _bal[to] += (amount - tax);\r
        }\r
        if (tax > 0) {\r
            _bal[address(this)] += tax;\r
            emit Transfer(from, address(this), tax);\r
        }\r
        emit Transfer(from, to, amount - tax);\r
    }\r
\r
    // --- Swapping & payouts ---\r
    function _swapTokensForETH(uint256 amount) internal swapping {\r
        address[] memory path = new address[](2);\r
        path[0] = address(this);\r
        path[1] = _router.WETH();\r
        _approveInternal(address(this), address(_router), amount);\r
        uint256 beforeBal = address(this).balance;\r
        _router.swapExactTokensForETHSupportingFeeOnTransferTokens(\r
            amount, 0, path, address(this), block.timestamp\r
        );\r
        uint256 gained = address(this).balance - beforeBal;\r
        emit AutoSwap(amount, gained);\r
    }\r
\r
    function _payout(uint256 amount) internal {\r
        uint256 half = amount / 2;\r
        _safeSend(marketingWallet, half);\r
        _safeSend(developmentWallet, amount - half); // remainder to dev\r
        emit Payout(amount, half);\r
    }\r
\r
    function _safeSend(address payable to, uint256 value) internal {\r
        (bool ok, ) = to.call{value: value}("");\r
        require(ok, "eth send failed");\r
    }\r
\r
    function _approveInternal(address owner_, address spender, uint256 amount) internal {\r
        _allow[owner_][spender] = amount;\r
        emit Approval(owner_, spender, amount);\r
    }\r
\r
    // --- Admin / Ops ---\r
\r
    /// @notice Set the UniswapV2 pair address once you've created it.\r
    function setPair(address pair_) external onlyOwner {\r
        require(pair == address(0), "pair set");\r
        require(pair_ != address(0), "pair=0");\r
        pair = pair_;\r
        emit PairSet(pair_);\r
    }\r
\r
    /// @notice Open trading window (starts the 15-minute limit period) and enable swapbacks.\r
    function setTradingOpen() external onlyOwner {\r
        require(!tradingOpen, "open");\r
        tradingOpen = true;\r
        swapEnabled = true;\r
        launchTime = block.timestamp;\r
        emit TradingOpened(launchTime);\r
    }\r
\r
    /// @notice Manual swap of contract's token pot to ETH (testing/helper).\r
    function manualSwap() external onlyOwner {\r
        uint256 pot = _bal[address(this)];\r
        require(pot > 0, "no tokens");\r
        _swapTokensForETH(pot);\r
    }\r
\r
    /// @notice Manual ETH send to wallets (testing/helper).\r
    function manualSendETH(uint256 amount) external onlyOwner {\r
        require(address(this).balance >= amount, "not enough ETH");\r
        _payout(amount);\r
    }\r
\r
    /// @notice Manual token send (withdraw taxed tokens) to owner (testing/helper).\r
    function manualSendTokens() external onlyOwner {\r
        uint256 pot = _bal[address(this)];\r
        require(pot > 0, "no tokens");\r
        _transfer(address(this), msg.sender, pot);\r
    }\r
\r
    // Accept ETH from router swaps\r
    receive() external payable {}\r
}\r
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}