NodexLabToken

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

/*
                                             
                                             
                         ****                
                      ***********            
                  ******************         
                ***********************      
             *****************************   
           ********************************* 
        ** *******        ****       ******* 
       *** *******         ***       ******* 
 ****      ****             **      ******** 
 ********* ****              *      ******** 
     ***** *******                  ******** 
     *****     ***       *          ******** 
               ***       **          ******* 
           *******       ***         ******* 
           *******       *****      ******** 
            *******************************  
               *************************     
                  *******************        
                     *************           
                         *****               
                                             
*/

// Nodex Lab - https://nodexlab.io/
// Twitter: https://x.com/nodexlab
// Telegram: https://t.me/nodexlab

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

abstract contract Ownable {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor() { _owner = msg.sender; emit OwnershipTransferred(address(0), msg.sender); }
    function owner() public view returns (address) { return _owner; }
    modifier onlyOwner() { require(msg.sender == _owner, "Ownable: caller is not the owner"); _; }
    function renounceOwnership() external onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); }
}

interface IUniswapV2Router02 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

contract NodexLabToken is IERC20, Ownable {
    string private constant _NAME   = "Nodex Lab";
    string private constant _SYMBOL = "NODEX";
    uint8  private constant _DECIMALS = 9;
    uint256 private constant _SUPPLY = 100_000_000 * 10**_DECIMALS;

    mapping(address => uint256) private _bal;
    mapping(address => mapping(address => uint256)) private _allow;

    uint256 private constant TAX_RATE = 5;
    address payable public marketingWallet;
    address payable public developmentWallet;

    uint256 public constant TAX_SWAP_THRESHOLD = 500_000 * 10**_DECIMALS;
    uint256 public constant MIN_BUYS_BEFORE_SWAP = 30;
    uint256 public buyCount;
    bool    public swapEnabled;

    uint256 public constant MAX_TX = 1_500_000 * 10**_DECIMALS;
    uint256 public constant MAX_WALLET = 1_500_000 * 10**_DECIMALS;
    uint256 public launchTime;
    mapping(address => bool) public isExcludedFromLimits;

    IUniswapV2Router02 private immutable _router;
    address public pair;
    bool public tradingOpen;

    bool private _inSwap;
    modifier swapping() { _inSwap = true; _; _inSwap = false; }

    event TradingOpened(uint256 at);
    event PairSet(address pair);
    event AutoSwap(uint256 tokensSold, uint256 ethReceived);
    event Payout(uint256 totalEth, uint256 halfEach);

    constructor(address _marketing, address _development) {
        require(_marketing != address(0) && _development != address(0), "wallet=0");
        marketingWallet   = payable(_marketing);
        developmentWallet = payable(_development);

        _bal[msg.sender] = _SUPPLY;
        isExcludedFromLimits[msg.sender] = true;
        isExcludedFromLimits[address(this)] = true;
        isExcludedFromLimits[marketingWallet] = true;
        isExcludedFromLimits[developmentWallet] = true;

        _router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

        emit Transfer(address(0), msg.sender, _SUPPLY);
    }

    function name() external pure returns (string memory) { return _NAME; }
    function symbol() external pure returns (string memory) { return _SYMBOL; }
    function decimals() external pure returns (uint8) { return _DECIMALS; }
    function totalSupply() external pure override returns (uint256) { return _SUPPLY; }
    function balanceOf(address account) public view override returns (uint256) { return _bal[account]; }
    function allowance(address owner_, address spender) external view override returns (uint256) { return _allow[owner_][spender]; }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _allow[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transfer(address to, uint256 amount) external override returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external override returns (bool) {
        _transfer(from, to, amount);
        uint256 curr = _allow[from][msg.sender];
        require(curr >= amount, "allowance");
        unchecked { _allow[from][msg.sender] = curr - amount; }
        return true;
    }

    function _transfer(address from, address to, uint256 amount) internal {
        require(from != address(0) && to != address(0), "zero addr");
        require(amount > 0, "amt=0");

        uint256 fromBal = _bal[from];
        require(fromBal >= amount, "bal");

        uint256 tax = 0;
        if (!_inSwap && from != owner() && to != owner()) {
            tax = (amount * TAX_RATE) / 100;
        }

        if (tradingOpen && launchTime != 0 && from == pair && to != address(_router) && !isExcludedFromLimits[to]) {
            if (block.timestamp < launchTime + 15 minutes) {
                require(amount <= MAX_TX, "maxTx");
                require(_bal[to] + (amount - tax) <= MAX_WALLET, "maxWallet");
            }
            buyCount += 1;
        }

        if (from != pair && !_inSwap && swapEnabled) {
            uint256 pot = _bal[address(this)];
            if (pot > TAX_SWAP_THRESHOLD && buyCount > MIN_BUYS_BEFORE_SWAP) {
                _swapTokensForETH(pot);
                uint256 ethBal = address(this).balance;
                if (ethBal >= 0.1 ether) {
                    _payout(ethBal);
                }
            }
        }

        unchecked {
            _bal[from] = fromBal - amount;
            _bal[to] += (amount - tax);
        }
        if (tax > 0) {
            _bal[address(this)] += tax;
            emit Transfer(from, address(this), tax);
        }
        emit Transfer(from, to, amount - tax);
    }

    function _swapTokensForETH(uint256 amount) internal swapping {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _router.WETH();
        _approveInternal(address(this), address(_router), amount);
        uint256 beforeBal = address(this).balance;
        _router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amount, 0, path, address(this), block.timestamp
        );
        uint256 gained = address(this).balance - beforeBal;
        emit AutoSwap(amount, gained);
    }

    function _payout(uint256 amount) internal {
        uint256 half = amount / 2;
        _safeSend(marketingWallet, half);
        _safeSend(developmentWallet, amount - half);
        emit Payout(amount, half);
    }

    function _safeSend(address payable to, uint256 value) internal {
        (bool ok, ) = to.call{value: value}("");
        require(ok, "eth send failed");
    }

    function _approveInternal(address owner_, address spender, uint256 amount) internal {
        _allow[owner_][spender] = amount;
        emit Approval(owner_, spender, amount);
    }

    function setPair(address pair_) external onlyOwner {
        require(pair == address(0), "pair set");
        require(pair_ != address(0), "pair=0");
        pair = pair_;
        emit PairSet(pair_);
    }

    function setTradingOpen() external onlyOwner {
        require(!tradingOpen, "open");
        tradingOpen = true;
        swapEnabled = true;
        launchTime = block.timestamp;
        emit TradingOpened(launchTime);
    }

    function manualSwap() external onlyOwner {
        uint256 pot = _bal[address(this)];
        require(pot > 0, "no tokens");
        _swapTokensForETH(pot);
    }

    function manualSendETH(uint256 amount) external onlyOwner {
        require(address(this).balance >= amount, "not enough ETH");
        _payout(amount);
    }

    function manualSendTokens() external onlyOwner {
        uint256 pot = _bal[address(this)];
        require(pot > 0, "no tokens");
        _transfer(address(this), msg.sender, pot);
    }

    receive() external payable {}
}