NODEPILOTAI

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

/*
───────────────────────────────────────────────────────────────────────────────
 _   _           _      ____  _ _       _        _    ___ 
| \ | | ___   __| | ___|  _ \(_) | ___ | |_     / \  |_ _|
|  \| |/ _ \ / _` |/ _ \ |_) | | |/ _ \| __|   / _ \  | | 
| |\  | (_) | (_| |  __/  __/| | | (_) | |_   / ___ \ | | 
|_| \_|\___/ \__,_|\___|_|   |_|_|\___/ \__| /_/   \_\___|
───────────────────────────────────────────────────────────────────────────────

NodePilot is a modular n8n-style automation platform built specifically for
crypto workflows. It allows users to visually connect on-chain and off-chain
actions into smart, automated flows — without writing code.

Create bots, agents, and trading strategies that interact directly with
blockchains, APIs, wallets, and market data in real time.

Whether you’re automating token launches, wallet tracking, trading signals,
or Telegram alerts, NodePilot provides a secure, plug-and-play environment with:

*Wallet-aware nodes for signing, buying, selling, and monitoring transactions  
*DeFi integrations (DEX, staking, liquidity, and analytics)  
*AI & data modules for on-chain intelligence, alpha discovery, and sentiment tracking  
*Custom flow builder using drag-and-drop logic for any crypto automation  

NodePilot makes crypto automation accessible and easy — from casual traders to
professional quant builders — all in one modular visual workspace.

Website:   https://nodepilot.app/  
Telegram:  https://t.me/nodepilotai 
Twitter:   https://x.com/nodepilot_x
───────────────────────────────────────────────────────────────────────────────
 */

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); }
}

contract NODEPILOTAI is IERC20, Ownable {
    // --- Token data ---
    string private constant _NAME   = "NodePilot AI";
    string private constant _SYMBOL = "NODA";
    uint8  private constant _DECIMALS = 9;
    uint256 private constant _SUPPLY = 100_000_000 * 10**_DECIMALS;

    // --- Accounting ---
    mapping(address => uint256) private _bal;
    mapping(address => mapping(address => uint256)) private _allow;

    // --- Fee / distribution ---
    uint256 private constant TAX_RATE = 5;
    address payable public marketingWallet;
    address payable public developmentWallet;

    // --- State ---
    bool public tradingOpen = true;
    address public pair;

    // --- Events ---
    event PairSet(address pair);

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

        _bal[msg.sender] = _SUPPLY;

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

    // --- ERC20 Basics ---
    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 (from != owner() && to != owner()) {
            tax = (amount * TAX_RATE) / 100;
        }

        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 setPair(address pair_) external onlyOwner {
        require(pair == address(0), "pair already set");
        require(pair_ != address(0), "pair=0");
        pair = pair_;
        emit PairSet(pair_);
    }

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

    function manualSendETH(uint256 amount) external onlyOwner {
        require(address(this).balance >= amount, "not enough ETH");
        (bool ok, ) = payable(msg.sender).call{value: amount}("");
        require(ok, "eth send failed");
    }

    // --- Read Helpers ---
    function getTokenInfo() external pure returns (string memory, string memory, uint8, uint256) {
        return (_NAME, _SYMBOL, _DECIMALS, _SUPPLY);
    }

    function getDistributionWallets() external view returns (address, address) {
        return (marketingWallet, developmentWallet);
    }

    function getContractState() external view returns (bool, address) {
        return (tradingOpen, pair);
    }

    function getTaxInfo() external pure returns (uint256) {
        return TAX_RATE;
    }

    function getContractBalances() external view returns (uint256 tokenBalance, uint256 ethBalance) {
        return (_bal[address(this)], address(this).balance);
    }

    receive() external payable {}
}